Coverage Report - com.googlecode.sparkleg.SparqlT
 
Classes in this File Line Coverage Branch Coverage Complexity
SparqlT
0%
0/8555
0%
0/3023
9,493
SparqlT$add_return
0%
0/2
N/A
9,493
SparqlT$aggregate_return
0%
0/2
N/A
9,493
SparqlT$anon_return
0%
0/2
N/A
9,493
SparqlT$argList_return
0%
0/2
N/A
9,493
SparqlT$askQuery_return
0%
0/2
N/A
9,493
SparqlT$baseDecl_return
0%
0/2
N/A
9,493
SparqlT$bind_return
0%
0/2
N/A
9,493
SparqlT$bindingValueList_return
0%
0/2
N/A
9,493
SparqlT$bindingValue_return
0%
0/2
N/A
9,493
SparqlT$bindingsClause_return
0%
0/2
N/A
9,493
SparqlT$blankNode_return
0%
0/2
N/A
9,493
SparqlT$booleanLiteral_return
0%
0/2
N/A
9,493
SparqlT$brackettedExpression_return
0%
0/2
N/A
9,493
SparqlT$builtInCall_return
0%
0/2
N/A
9,493
SparqlT$clear_return
0%
0/2
N/A
9,493
SparqlT$constraint_return
0%
0/2
N/A
9,493
SparqlT$constructQuery_return
0%
0/2
N/A
9,493
SparqlT$constructTemplate_return
0%
0/2
N/A
9,493
SparqlT$constructTriples_return
0%
0/2
N/A
9,493
SparqlT$copy_return
0%
0/2
N/A
9,493
SparqlT$create_return
0%
0/2
N/A
9,493
SparqlT$datasetClause_return
0%
0/2
N/A
9,493
SparqlT$deleteClause_return
0%
0/2
N/A
9,493
SparqlT$deleteData_return
0%
0/2
N/A
9,493
SparqlT$deleteWhere_return
0%
0/2
N/A
9,493
SparqlT$delete_return
0%
0/2
N/A
9,493
SparqlT$describeQuery_return
0%
0/2
N/A
9,493
SparqlT$drop_return
0%
0/2
N/A
9,493
SparqlT$existsFunction_return
0%
0/2
N/A
9,493
SparqlT$expressionList_return
0%
0/2
N/A
9,493
SparqlT$expression_return
0%
0/2
N/A
9,493
SparqlT$filter_return
0%
0/2
N/A
9,493
SparqlT$functionCall_return
0%
0/2
N/A
9,493
SparqlT$graphGraphPattern_return
0%
0/2
N/A
9,493
SparqlT$graphNode_return
0%
0/2
N/A
9,493
SparqlT$graphOrDefault_return
0%
0/2
N/A
9,493
SparqlT$graphPatternNotTriples_return
0%
0/2
N/A
9,493
SparqlT$graphRefAll_return
0%
0/2
N/A
9,493
SparqlT$graphRef_return
0%
0/2
N/A
9,493
SparqlT$graphTerm_return
0%
0/2
N/A
9,493
SparqlT$groupClause_return
0%
0/2
N/A
9,493
SparqlT$groupCondition_return
0%
0/2
N/A
9,493
SparqlT$groupGraphPatternSubDetail_return
0%
0/2
N/A
9,493
SparqlT$groupGraphPatternSub_return
0%
0/2
N/A
9,493
SparqlT$groupGraphPattern_return
0%
0/2
N/A
9,493
SparqlT$groupOrUnionGraphPattern_return
0%
0/2
N/A
9,493
SparqlT$havingClause_return
0%
0/2
N/A
9,493
SparqlT$insertClause_return
0%
0/2
N/A
9,493
SparqlT$insert_return
0%
0/2
N/A
9,493
SparqlT$iriRefOrFunction_return
0%
0/2
N/A
9,493
SparqlT$iriRef_return
0%
0/2
N/A
9,493
SparqlT$limitOffsetClauses_return
0%
0/2
N/A
9,493
SparqlT$load_return
0%
0/2
N/A
9,493
SparqlT$minusGraphPattern_return
0%
0/2
N/A
9,493
SparqlT$modify_return
0%
0/2
N/A
9,493
SparqlT$move_return
0%
0/2
N/A
9,493
SparqlT$nil_return
0%
0/2
N/A
9,493
SparqlT$notExistsFunction_return
0%
0/2
N/A
9,493
SparqlT$numericLiteralNegative_return
0%
0/2
N/A
9,493
SparqlT$numericLiteralPositive_return
0%
0/2
N/A
9,493
SparqlT$numericLiteralUnsigned_return
0%
0/2
N/A
9,493
SparqlT$numericLiteral_return
0%
0/2
N/A
9,493
SparqlT$objectList_return
0%
0/2
N/A
9,493
SparqlT$optionalGraphPattern_return
0%
0/2
N/A
9,493
SparqlT$orderClause_return
0%
0/2
N/A
9,493
SparqlT$orderCondition_return
0%
0/2
N/A
9,493
SparqlT$pathEltOrInverse_return
0%
0/2
N/A
9,493
SparqlT$pathElt_return
0%
0/2
N/A
9,493
SparqlT$pathMod_return
0%
0/2
N/A
9,493
SparqlT$pathNegatedPropertySet_return
0%
0/2
N/A
9,493
SparqlT$pathOneInPropertySet_return
0%
0/2
N/A
9,493
SparqlT$pathPrimary_return
0%
0/2
N/A
9,493
SparqlT$pathSequence_return
0%
0/2
N/A
9,493
SparqlT$path_return
0%
0/2
N/A
9,493
SparqlT$prefixDecl_return
0%
0/2
N/A
9,493
SparqlT$prefixedName_return
0%
0/2
N/A
9,493
SparqlT$primaryExpression_return
0%
0/2
N/A
9,493
SparqlT$prologue_return
0%
0/2
N/A
9,493
SparqlT$propertyListNotEmptyDetails_return
0%
0/2
N/A
9,493
SparqlT$propertyListNotEmpty_return
0%
0/2
N/A
9,493
SparqlT$quadPattern_return
0%
0/2
N/A
9,493
SparqlT$quadsNotTriples_return
0%
0/2
N/A
9,493
SparqlT$quads_return
0%
0/2
N/A
9,493
SparqlT$query_return
0%
0/2
N/A
9,493
SparqlT$rdfLiteral_return
0%
0/2
N/A
9,493
SparqlT$regexExpression_return
0%
0/2
N/A
9,493
SparqlT$selectClause_return
0%
0/2
N/A
9,493
SparqlT$selectQuery_return
0%
0/2
N/A
9,493
SparqlT$selectVariables_return
0%
0/2
N/A
9,493
SparqlT$serviceGraphPattern_return
0%
0/2
N/A
9,493
SparqlT$solutionModifier_return
0%
0/2
N/A
9,493
SparqlT$string_return
0%
0/2
N/A
9,493
SparqlT$subSelect_return
0%
0/2
N/A
9,493
SparqlT$subStringExpression_return
0%
0/2
N/A
9,493
SparqlT$triplesBlock_return
0%
0/2
N/A
9,493
SparqlT$triplesNode_return
0%
0/2
N/A
9,493
SparqlT$triplesSameSubjectPath_return
0%
0/2
N/A
9,493
SparqlT$triplesSameSubject_return
0%
0/2
N/A
9,493
SparqlT$triplesTemplate_return
0%
0/2
N/A
9,493
SparqlT$unaryExpression_return
0%
0/2
N/A
9,493
SparqlT$update_return
0%
0/2
N/A
9,493
SparqlT$usingClause_return
0%
0/2
N/A
9,493
SparqlT$varOrIRIref_return
0%
0/2
N/A
9,493
SparqlT$varOrTerm_return
0%
0/2
N/A
9,493
SparqlT$var_return
0%
0/2
N/A
9,493
SparqlT$verb_return
0%
0/2
N/A
9,493
SparqlT$whereClause_return
0%
0/2
N/A
9,493
 
 1  
 // $ANTLR 3.4 com\\googlecode\\sparkleg\\SparqlT.g 2011-12-06 23:49:26
 2  
 
 3  
     package com.googlecode.sparkleg;
 4  
 
 5  
 
 6  
 import org.antlr.runtime.*;
 7  
 import org.antlr.runtime.tree.*;
 8  
 import java.util.Stack;
 9  
 import java.util.List;
 10  
 import java.util.ArrayList;
 11  
 
 12  
 
 13  
 /**
 14  
  * @author Simone Tripodi   (simone.tripodi)
 15  
  * @author Michele Mostarda (michele.mostarda)
 16  
  * @author Juergen Pfundt   (Juergen.Pfundt)
 17  
  * @version $Id: Sparql.g 161 2011-05-23 22:14:39Z Juergen.Pfundt@web.de $
 18  
  */
 19  
 @SuppressWarnings({"all", "warnings", "unchecked"})
 20  
 public class SparqlT extends TreeParser {
 21  0
     public static final String[] tokenNames = new String[] {
 22  
         "<invalid>", "<EOR>", "<DOWN>", "<UP>", "A", "ABS", "ADD", "ALL", "AND", "ANY", "ARG_LIST", "AS", "ASC", "ASK", "ASTERISK", "AVG", "BASE", "BIND", "BINDINGS", "BINDING_VALUE", "BLANK_NODE", "BLANK_NODE_LABEL", "BNODE", "BOUND", "BRACKETTED_EXPRESSION", "BY", "CEIL", "CLEAR", "CLOSE_BRACE", "CLOSE_CURLY_BRACE", "CLOSE_SQUARE_BRACKET", "COALESCE", "COLLECTION", "COMMA", "COMMENT", "CONCAT", "CONSTRUCT", "CONSTRUCT_TRIPLES", "CONTAINS", "COPY", "COUNT", "CREATE", "DATA", "DATATYPE", "DAY", "DECIMAL", "DECIMAL_NEGATIVE", "DECIMAL_POSITIVE", "DEFAULT", "DELETE", "DESC", "DESCRIBE", "DIGIT", "DISTINCT", "DIVIDE", "DOT", "DOUBLE", "DOUBLE_NEGATIVE", "DOUBLE_POSITIVE", "DROP", "ECHAR", "ENCODE_FOR_URI", "EOL", "EQUAL", "EXISTS", "EXPONENT", "EXPRESSION_LIST", "FALSE", "FILTER", "FLOOR", "FROM", "FUNCTION", "GRAPH", "GREATER", "GREATER_EQUAL", "GROUP", "GROUP_BY", "GROUP_CONCAT", "GROUP_CONDITION", "GROUP_GRAPH_PATTERN", "HAVING", "HOURS", "IF", "IN", "INSERT", "INTEGER", "INTEGER_NEGATIVE", "INTEGER_POSITIVE", "INTO", "INVERSE", "IRI", "IRI_REF", "IRI_REF_CHARACTERS", "ISBLANK", "ISIRI", "ISLITERAL", "ISNUMERIC", "ISURI", "LANG", "LANGMATCHES", "LANGTAG", "LCASE", "LESS", "LESS_EQUAL", "LIMIT", "LOAD", "MAX", "MD5", "MIN", "MINUS", "MINUS_KEYWORD", "MINUTES", "MODIFY", "MONTH", "MOVE", "NAMED", "NEGATION", "NOT", "NOT_EQUAL", "NOT_EXISTS", "NOW", "OBJECT", "OFFSET", "OPEN_BRACE", "OPEN_CURLY_BRACE", "OPEN_SQUARE_BRACKET", "OPTIONAL", "OR", "ORDER", "ORDER_BY", "ORDER_CONDITION", "PATH", "PATH_NEGATED", "PATH_PRIMARY", "PATH_SEQUENCE", "PIPE", "PLUS", "PNAME_LN", "PNAME_NS", "PN_CHARS", "PN_CHARS_BASE", "PN_CHARS_U", "PN_LOCAL", "PN_PREFIX", "PREDICATE", "PREFIX", "PROLOGUE", "QUERY", "QUESTION_MARK", "RAND", "REDUCED", "REFERENCE", "REGEX", "REPLACE", "ROUND", "SAMETERM", "SAMPLE", "SECONDS", "SELECT", "SELECT_CLAUSE", "SEMICOLON", "SEPARATOR", "SERVICE", "SHA1", "SHA224", "SHA256", "SHA384", "SHA512", "SIGN", "SILENT", "STR", "STRAFTER", "STRBEFORE", "STRDT", "STRENDS", "STRING_LITERAL1", "STRING_LITERAL2", "STRING_LITERAL_LONG1", "STRING_LITERAL_LONG2", "STRLANG", "STRLEN", "STRSTARTS", "SUBJECT", "SUBSELECT", "SUBSTR", "SUM", "TIMEZONE", "TO", "TRIPLES_BLOCK", "TRIPLES_NODE", "TRIPLES_SAME_SUBJECT", "TRIPLES_TEMPLATE", "TRUE", "TZ", "UCASE", "UNARY", "UNDEF", "UNION", "UPDATE", "URI", "USING", "VAR", "VAR1", "VAR2", "VARNAME", "WHERE", "WHERE_CLAUSE", "WITH", "WS", "YEAR"
 23  
     };
 24  
 
 25  
     public static final int EOF=-1;
 26  
     public static final int A=4;
 27  
     public static final int ABS=5;
 28  
     public static final int ADD=6;
 29  
     public static final int ALL=7;
 30  
     public static final int AND=8;
 31  
     public static final int ANY=9;
 32  
     public static final int ARG_LIST=10;
 33  
     public static final int AS=11;
 34  
     public static final int ASC=12;
 35  
     public static final int ASK=13;
 36  
     public static final int ASTERISK=14;
 37  
     public static final int AVG=15;
 38  
     public static final int BASE=16;
 39  
     public static final int BIND=17;
 40  
     public static final int BINDINGS=18;
 41  
     public static final int BINDING_VALUE=19;
 42  
     public static final int BLANK_NODE=20;
 43  
     public static final int BLANK_NODE_LABEL=21;
 44  
     public static final int BNODE=22;
 45  
     public static final int BOUND=23;
 46  
     public static final int BRACKETTED_EXPRESSION=24;
 47  
     public static final int BY=25;
 48  
     public static final int CEIL=26;
 49  
     public static final int CLEAR=27;
 50  
     public static final int CLOSE_BRACE=28;
 51  
     public static final int CLOSE_CURLY_BRACE=29;
 52  
     public static final int CLOSE_SQUARE_BRACKET=30;
 53  
     public static final int COALESCE=31;
 54  
     public static final int COLLECTION=32;
 55  
     public static final int COMMA=33;
 56  
     public static final int COMMENT=34;
 57  
     public static final int CONCAT=35;
 58  
     public static final int CONSTRUCT=36;
 59  
     public static final int CONSTRUCT_TRIPLES=37;
 60  
     public static final int CONTAINS=38;
 61  
     public static final int COPY=39;
 62  
     public static final int COUNT=40;
 63  
     public static final int CREATE=41;
 64  
     public static final int DATA=42;
 65  
     public static final int DATATYPE=43;
 66  
     public static final int DAY=44;
 67  
     public static final int DECIMAL=45;
 68  
     public static final int DECIMAL_NEGATIVE=46;
 69  
     public static final int DECIMAL_POSITIVE=47;
 70  
     public static final int DEFAULT=48;
 71  
     public static final int DELETE=49;
 72  
     public static final int DESC=50;
 73  
     public static final int DESCRIBE=51;
 74  
     public static final int DIGIT=52;
 75  
     public static final int DISTINCT=53;
 76  
     public static final int DIVIDE=54;
 77  
     public static final int DOT=55;
 78  
     public static final int DOUBLE=56;
 79  
     public static final int DOUBLE_NEGATIVE=57;
 80  
     public static final int DOUBLE_POSITIVE=58;
 81  
     public static final int DROP=59;
 82  
     public static final int ECHAR=60;
 83  
     public static final int ENCODE_FOR_URI=61;
 84  
     public static final int EOL=62;
 85  
     public static final int EQUAL=63;
 86  
     public static final int EXISTS=64;
 87  
     public static final int EXPONENT=65;
 88  
     public static final int EXPRESSION_LIST=66;
 89  
     public static final int FALSE=67;
 90  
     public static final int FILTER=68;
 91  
     public static final int FLOOR=69;
 92  
     public static final int FROM=70;
 93  
     public static final int FUNCTION=71;
 94  
     public static final int GRAPH=72;
 95  
     public static final int GREATER=73;
 96  
     public static final int GREATER_EQUAL=74;
 97  
     public static final int GROUP=75;
 98  
     public static final int GROUP_BY=76;
 99  
     public static final int GROUP_CONCAT=77;
 100  
     public static final int GROUP_CONDITION=78;
 101  
     public static final int GROUP_GRAPH_PATTERN=79;
 102  
     public static final int HAVING=80;
 103  
     public static final int HOURS=81;
 104  
     public static final int IF=82;
 105  
     public static final int IN=83;
 106  
     public static final int INSERT=84;
 107  
     public static final int INTEGER=85;
 108  
     public static final int INTEGER_NEGATIVE=86;
 109  
     public static final int INTEGER_POSITIVE=87;
 110  
     public static final int INTO=88;
 111  
     public static final int INVERSE=89;
 112  
     public static final int IRI=90;
 113  
     public static final int IRI_REF=91;
 114  
     public static final int IRI_REF_CHARACTERS=92;
 115  
     public static final int ISBLANK=93;
 116  
     public static final int ISIRI=94;
 117  
     public static final int ISLITERAL=95;
 118  
     public static final int ISNUMERIC=96;
 119  
     public static final int ISURI=97;
 120  
     public static final int LANG=98;
 121  
     public static final int LANGMATCHES=99;
 122  
     public static final int LANGTAG=100;
 123  
     public static final int LCASE=101;
 124  
     public static final int LESS=102;
 125  
     public static final int LESS_EQUAL=103;
 126  
     public static final int LIMIT=104;
 127  
     public static final int LOAD=105;
 128  
     public static final int MAX=106;
 129  
     public static final int MD5=107;
 130  
     public static final int MIN=108;
 131  
     public static final int MINUS=109;
 132  
     public static final int MINUS_KEYWORD=110;
 133  
     public static final int MINUTES=111;
 134  
     public static final int MODIFY=112;
 135  
     public static final int MONTH=113;
 136  
     public static final int MOVE=114;
 137  
     public static final int NAMED=115;
 138  
     public static final int NEGATION=116;
 139  
     public static final int NOT=117;
 140  
     public static final int NOT_EQUAL=118;
 141  
     public static final int NOT_EXISTS=119;
 142  
     public static final int NOW=120;
 143  
     public static final int OBJECT=121;
 144  
     public static final int OFFSET=122;
 145  
     public static final int OPEN_BRACE=123;
 146  
     public static final int OPEN_CURLY_BRACE=124;
 147  
     public static final int OPEN_SQUARE_BRACKET=125;
 148  
     public static final int OPTIONAL=126;
 149  
     public static final int OR=127;
 150  
     public static final int ORDER=128;
 151  
     public static final int ORDER_BY=129;
 152  
     public static final int ORDER_CONDITION=130;
 153  
     public static final int PATH=131;
 154  
     public static final int PATH_NEGATED=132;
 155  
     public static final int PATH_PRIMARY=133;
 156  
     public static final int PATH_SEQUENCE=134;
 157  
     public static final int PIPE=135;
 158  
     public static final int PLUS=136;
 159  
     public static final int PNAME_LN=137;
 160  
     public static final int PNAME_NS=138;
 161  
     public static final int PN_CHARS=139;
 162  
     public static final int PN_CHARS_BASE=140;
 163  
     public static final int PN_CHARS_U=141;
 164  
     public static final int PN_LOCAL=142;
 165  
     public static final int PN_PREFIX=143;
 166  
     public static final int PREDICATE=144;
 167  
     public static final int PREFIX=145;
 168  
     public static final int PROLOGUE=146;
 169  
     public static final int QUERY=147;
 170  
     public static final int QUESTION_MARK=148;
 171  
     public static final int RAND=149;
 172  
     public static final int REDUCED=150;
 173  
     public static final int REFERENCE=151;
 174  
     public static final int REGEX=152;
 175  
     public static final int REPLACE=153;
 176  
     public static final int ROUND=154;
 177  
     public static final int SAMETERM=155;
 178  
     public static final int SAMPLE=156;
 179  
     public static final int SECONDS=157;
 180  
     public static final int SELECT=158;
 181  
     public static final int SELECT_CLAUSE=159;
 182  
     public static final int SEMICOLON=160;
 183  
     public static final int SEPARATOR=161;
 184  
     public static final int SERVICE=162;
 185  
     public static final int SHA1=163;
 186  
     public static final int SHA224=164;
 187  
     public static final int SHA256=165;
 188  
     public static final int SHA384=166;
 189  
     public static final int SHA512=167;
 190  
     public static final int SIGN=168;
 191  
     public static final int SILENT=169;
 192  
     public static final int STR=170;
 193  
     public static final int STRAFTER=171;
 194  
     public static final int STRBEFORE=172;
 195  
     public static final int STRDT=173;
 196  
     public static final int STRENDS=174;
 197  
     public static final int STRING_LITERAL1=175;
 198  
     public static final int STRING_LITERAL2=176;
 199  
     public static final int STRING_LITERAL_LONG1=177;
 200  
     public static final int STRING_LITERAL_LONG2=178;
 201  
     public static final int STRLANG=179;
 202  
     public static final int STRLEN=180;
 203  
     public static final int STRSTARTS=181;
 204  
     public static final int SUBJECT=182;
 205  
     public static final int SUBSELECT=183;
 206  
     public static final int SUBSTR=184;
 207  
     public static final int SUM=185;
 208  
     public static final int TIMEZONE=186;
 209  
     public static final int TO=187;
 210  
     public static final int TRIPLES_BLOCK=188;
 211  
     public static final int TRIPLES_NODE=189;
 212  
     public static final int TRIPLES_SAME_SUBJECT=190;
 213  
     public static final int TRIPLES_TEMPLATE=191;
 214  
     public static final int TRUE=192;
 215  
     public static final int TZ=193;
 216  
     public static final int UCASE=194;
 217  
     public static final int UNARY=195;
 218  
     public static final int UNDEF=196;
 219  
     public static final int UNION=197;
 220  
     public static final int UPDATE=198;
 221  
     public static final int URI=199;
 222  
     public static final int USING=200;
 223  
     public static final int VAR=201;
 224  
     public static final int VAR1=202;
 225  
     public static final int VAR2=203;
 226  
     public static final int VARNAME=204;
 227  
     public static final int WHERE=205;
 228  
     public static final int WHERE_CLAUSE=206;
 229  
     public static final int WITH=207;
 230  
     public static final int WS=208;
 231  
     public static final int YEAR=209;
 232  
 
 233  
     // delegates
 234  
     public TreeParser[] getDelegates() {
 235  0
         return new TreeParser[] {};
 236  
     }
 237  
 
 238  
     // delegators
 239  
 
 240  
 
 241  
     public SparqlT(TreeNodeStream input) {
 242  0
         this(input, new RecognizerSharedState());
 243  0
     }
 244  
     public SparqlT(TreeNodeStream input, RecognizerSharedState state) {
 245  0
         super(input, state);
 246  0
     }
 247  
 
 248  0
 protected TreeAdaptor adaptor = new CommonTreeAdaptor();
 249  
 
 250  
 public void setTreeAdaptor(TreeAdaptor adaptor) {
 251  0
     this.adaptor = adaptor;
 252  0
 }
 253  
 public TreeAdaptor getTreeAdaptor() {
 254  0
     return adaptor;
 255  
 }
 256  0
     public String[] getTokenNames() { return SparqlT.tokenNames; }
 257  0
     public String getGrammarFileName() { return "com\\googlecode\\sparkleg\\SparqlT.g"; }
 258  
 
 259  
 
 260  0
     public static class query_return extends TreeRuleReturnScope {
 261  
         CommonTree tree;
 262  0
         public Object getTree() { return tree; }
 263  
     };
 264  
 
 265  
 
 266  
     // $ANTLR start "query"
 267  
     // com\\googlecode\\sparkleg\\SparqlT.g:37:1: query : ( ^( QUERY prologue ( selectQuery )? ( constructQuery )? ( describeQuery )? ( askQuery )? ) ( bindingsClause )? | ^( UPDATE ( update )+ ) );
 268  
     public final SparqlT.query_return query() throws RecognitionException {
 269  0
         SparqlT.query_return retval = new SparqlT.query_return();
 270  0
         retval.start = input.LT(1);
 271  
 
 272  
 
 273  0
         CommonTree root_0 = null;
 274  
 
 275  0
         CommonTree _first_0 = null;
 276  0
         CommonTree _last = null;
 277  
 
 278  0
         CommonTree QUERY1=null;
 279  0
         CommonTree UPDATE8=null;
 280  0
         SparqlT.prologue_return prologue2 =null;
 281  
 
 282  0
         SparqlT.selectQuery_return selectQuery3 =null;
 283  
 
 284  0
         SparqlT.constructQuery_return constructQuery4 =null;
 285  
 
 286  0
         SparqlT.describeQuery_return describeQuery5 =null;
 287  
 
 288  0
         SparqlT.askQuery_return askQuery6 =null;
 289  
 
 290  0
         SparqlT.bindingsClause_return bindingsClause7 =null;
 291  
 
 292  0
         SparqlT.update_return update9 =null;
 293  
 
 294  
 
 295  0
         CommonTree QUERY1_tree=null;
 296  0
         CommonTree UPDATE8_tree=null;
 297  
 
 298  
         try {
 299  
             // com\\googlecode\\sparkleg\\SparqlT.g:38:5: ( ^( QUERY prologue ( selectQuery )? ( constructQuery )? ( describeQuery )? ( askQuery )? ) ( bindingsClause )? | ^( UPDATE ( update )+ ) )
 300  0
             int alt7=2;
 301  0
             switch ( input.LA(1) ) {
 302  
             case QUERY:
 303  
                 {
 304  0
                 alt7=1;
 305  
                 }
 306  0
                 break;
 307  
             case UPDATE:
 308  
                 {
 309  0
                 alt7=2;
 310  
                 }
 311  0
                 break;
 312  
             default:
 313  0
                 NoViableAltException nvae =
 314  
                     new NoViableAltException("", 7, 0, input);
 315  
 
 316  0
                 throw nvae;
 317  
 
 318  
             }
 319  
 
 320  0
             switch (alt7) {
 321  
                 case 1 :
 322  
                     // com\\googlecode\\sparkleg\\SparqlT.g:38:7: ^( QUERY prologue ( selectQuery )? ( constructQuery )? ( describeQuery )? ( askQuery )? ) ( bindingsClause )?
 323  
                     {
 324  0
                     root_0 = (CommonTree)adaptor.nil();
 325  
 
 326  
 
 327  0
                     _last = (CommonTree)input.LT(1);
 328  
                     {
 329  0
                     CommonTree _save_last_1 = _last;
 330  0
                     CommonTree _first_1 = null;
 331  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 332  0
                     _last = (CommonTree)input.LT(1);
 333  0
                     QUERY1=(CommonTree)match(input,QUERY,FOLLOW_QUERY_in_query53); 
 334  0
                     QUERY1_tree = (CommonTree)adaptor.dupNode(QUERY1);
 335  
 
 336  
 
 337  0
                     root_1 = (CommonTree)adaptor.becomeRoot(QUERY1_tree, root_1);
 338  
 
 339  
 
 340  0
                     match(input, Token.DOWN, null); 
 341  0
                     _last = (CommonTree)input.LT(1);
 342  0
                     pushFollow(FOLLOW_prologue_in_query55);
 343  0
                     prologue2=prologue();
 344  
 
 345  0
                     state._fsp--;
 346  
 
 347  0
                     adaptor.addChild(root_1, prologue2.getTree());
 348  
 
 349  
 
 350  
                     // com\\googlecode\\sparkleg\\SparqlT.g:38:24: ( selectQuery )?
 351  0
                     int alt1=2;
 352  0
                     switch ( input.LA(1) ) {
 353  
                         case SELECT:
 354  
                             {
 355  0
                             alt1=1;
 356  
                             }
 357  
                             break;
 358  
                     }
 359  
 
 360  0
                     switch (alt1) {
 361  
                         case 1 :
 362  
                             // com\\googlecode\\sparkleg\\SparqlT.g:38:24: selectQuery
 363  
                             {
 364  0
                             _last = (CommonTree)input.LT(1);
 365  0
                             pushFollow(FOLLOW_selectQuery_in_query57);
 366  0
                             selectQuery3=selectQuery();
 367  
 
 368  0
                             state._fsp--;
 369  
 
 370  0
                             adaptor.addChild(root_1, selectQuery3.getTree());
 371  
 
 372  
 
 373  
                             }
 374  
                             break;
 375  
 
 376  
                     }
 377  
 
 378  
 
 379  
                     // com\\googlecode\\sparkleg\\SparqlT.g:38:37: ( constructQuery )?
 380  0
                     int alt2=2;
 381  0
                     switch ( input.LA(1) ) {
 382  
                         case CONSTRUCT:
 383  
                             {
 384  0
                             alt2=1;
 385  
                             }
 386  
                             break;
 387  
                     }
 388  
 
 389  0
                     switch (alt2) {
 390  
                         case 1 :
 391  
                             // com\\googlecode\\sparkleg\\SparqlT.g:38:37: constructQuery
 392  
                             {
 393  0
                             _last = (CommonTree)input.LT(1);
 394  0
                             pushFollow(FOLLOW_constructQuery_in_query60);
 395  0
                             constructQuery4=constructQuery();
 396  
 
 397  0
                             state._fsp--;
 398  
 
 399  0
                             adaptor.addChild(root_1, constructQuery4.getTree());
 400  
 
 401  
 
 402  
                             }
 403  
                             break;
 404  
 
 405  
                     }
 406  
 
 407  
 
 408  
                     // com\\googlecode\\sparkleg\\SparqlT.g:38:53: ( describeQuery )?
 409  0
                     int alt3=2;
 410  0
                     switch ( input.LA(1) ) {
 411  
                         case DESCRIBE:
 412  
                             {
 413  0
                             alt3=1;
 414  
                             }
 415  
                             break;
 416  
                     }
 417  
 
 418  0
                     switch (alt3) {
 419  
                         case 1 :
 420  
                             // com\\googlecode\\sparkleg\\SparqlT.g:38:53: describeQuery
 421  
                             {
 422  0
                             _last = (CommonTree)input.LT(1);
 423  0
                             pushFollow(FOLLOW_describeQuery_in_query63);
 424  0
                             describeQuery5=describeQuery();
 425  
 
 426  0
                             state._fsp--;
 427  
 
 428  0
                             adaptor.addChild(root_1, describeQuery5.getTree());
 429  
 
 430  
 
 431  
                             }
 432  
                             break;
 433  
 
 434  
                     }
 435  
 
 436  
 
 437  
                     // com\\googlecode\\sparkleg\\SparqlT.g:38:68: ( askQuery )?
 438  0
                     int alt4=2;
 439  0
                     switch ( input.LA(1) ) {
 440  
                         case ASK:
 441  
                             {
 442  0
                             alt4=1;
 443  
                             }
 444  
                             break;
 445  
                     }
 446  
 
 447  0
                     switch (alt4) {
 448  
                         case 1 :
 449  
                             // com\\googlecode\\sparkleg\\SparqlT.g:38:68: askQuery
 450  
                             {
 451  0
                             _last = (CommonTree)input.LT(1);
 452  0
                             pushFollow(FOLLOW_askQuery_in_query66);
 453  0
                             askQuery6=askQuery();
 454  
 
 455  0
                             state._fsp--;
 456  
 
 457  0
                             adaptor.addChild(root_1, askQuery6.getTree());
 458  
 
 459  
 
 460  
                             }
 461  
                             break;
 462  
 
 463  
                     }
 464  
 
 465  
 
 466  0
                     match(input, Token.UP, null); 
 467  0
                     adaptor.addChild(root_0, root_1);
 468  0
                     _last = _save_last_1;
 469  
                     }
 470  
 
 471  
 
 472  
                     // com\\googlecode\\sparkleg\\SparqlT.g:38:79: ( bindingsClause )?
 473  0
                     int alt5=2;
 474  0
                     switch ( input.LA(1) ) {
 475  
                         case BINDINGS:
 476  
                             {
 477  0
                             alt5=1;
 478  
                             }
 479  
                             break;
 480  
                     }
 481  
 
 482  0
                     switch (alt5) {
 483  
                         case 1 :
 484  
                             // com\\googlecode\\sparkleg\\SparqlT.g:38:79: bindingsClause
 485  
                             {
 486  0
                             _last = (CommonTree)input.LT(1);
 487  0
                             pushFollow(FOLLOW_bindingsClause_in_query70);
 488  0
                             bindingsClause7=bindingsClause();
 489  
 
 490  0
                             state._fsp--;
 491  
 
 492  0
                             adaptor.addChild(root_0, bindingsClause7.getTree());
 493  
 
 494  
 
 495  
                             }
 496  
                             break;
 497  
 
 498  
                     }
 499  
 
 500  
 
 501  
                     }
 502  0
                     break;
 503  
                 case 2 :
 504  
                     // com\\googlecode\\sparkleg\\SparqlT.g:39:7: ^( UPDATE ( update )+ )
 505  
                     {
 506  0
                     root_0 = (CommonTree)adaptor.nil();
 507  
 
 508  
 
 509  0
                     _last = (CommonTree)input.LT(1);
 510  
                     {
 511  0
                     CommonTree _save_last_1 = _last;
 512  0
                     CommonTree _first_1 = null;
 513  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 514  0
                     _last = (CommonTree)input.LT(1);
 515  0
                     UPDATE8=(CommonTree)match(input,UPDATE,FOLLOW_UPDATE_in_query80); 
 516  0
                     UPDATE8_tree = (CommonTree)adaptor.dupNode(UPDATE8);
 517  
 
 518  
 
 519  0
                     root_1 = (CommonTree)adaptor.becomeRoot(UPDATE8_tree, root_1);
 520  
 
 521  
 
 522  0
                     match(input, Token.DOWN, null); 
 523  
                     // com\\googlecode\\sparkleg\\SparqlT.g:39:16: ( update )+
 524  0
                     int cnt6=0;
 525  
                     loop6:
 526  
                     do {
 527  0
                         int alt6=2;
 528  0
                         switch ( input.LA(1) ) {
 529  
                         case PROLOGUE:
 530  
                             {
 531  0
                             alt6=1;
 532  
                             }
 533  
                             break;
 534  
 
 535  
                         }
 536  
 
 537  0
                         switch (alt6) {
 538  
                             case 1 :
 539  
                                 // com\\googlecode\\sparkleg\\SparqlT.g:39:16: update
 540  
                                 {
 541  0
                                 _last = (CommonTree)input.LT(1);
 542  0
                                 pushFollow(FOLLOW_update_in_query82);
 543  0
                                 update9=update();
 544  
 
 545  0
                                 state._fsp--;
 546  
 
 547  0
                                 adaptor.addChild(root_1, update9.getTree());
 548  
 
 549  
 
 550  
                                 }
 551  0
                                 break;
 552  
 
 553  
                             default :
 554  0
                                 if ( cnt6 >= 1 ) break loop6;
 555  0
                                 EarlyExitException eee =
 556  
                                     new EarlyExitException(6, input);
 557  0
                                 throw eee;
 558  
                         }
 559  0
                         cnt6++;
 560  0
                     } while (true);
 561  
 
 562  
 
 563  0
                     match(input, Token.UP, null); 
 564  0
                     adaptor.addChild(root_0, root_1);
 565  0
                     _last = _save_last_1;
 566  
                     }
 567  
 
 568  
 
 569  
                     }
 570  
                     break;
 571  
 
 572  
             }
 573  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 574  
 
 575  
         }
 576  0
         catch (RecognitionException re) {
 577  0
             reportError(re);
 578  0
             recover(input,re);
 579  
         }
 580  
 
 581  0
         finally {
 582  
                 // do for sure before leaving
 583  0
         }
 584  0
         return retval;
 585  
     }
 586  
     // $ANTLR end "query"
 587  
 
 588  
 
 589  0
     public static class prologue_return extends TreeRuleReturnScope {
 590  
         CommonTree tree;
 591  0
         public Object getTree() { return tree; }
 592  
     };
 593  
 
 594  
 
 595  
     // $ANTLR start "prologue"
 596  
     // com\\googlecode\\sparkleg\\SparqlT.g:42:1: prologue : ^( PROLOGUE ( baseDecl )* ( prefixDecl )* ) ;
 597  
     public final SparqlT.prologue_return prologue() throws RecognitionException {
 598  0
         SparqlT.prologue_return retval = new SparqlT.prologue_return();
 599  0
         retval.start = input.LT(1);
 600  
 
 601  
 
 602  0
         CommonTree root_0 = null;
 603  
 
 604  0
         CommonTree _first_0 = null;
 605  0
         CommonTree _last = null;
 606  
 
 607  0
         CommonTree PROLOGUE10=null;
 608  0
         SparqlT.baseDecl_return baseDecl11 =null;
 609  
 
 610  0
         SparqlT.prefixDecl_return prefixDecl12 =null;
 611  
 
 612  
 
 613  0
         CommonTree PROLOGUE10_tree=null;
 614  
 
 615  
         try {
 616  
             // com\\googlecode\\sparkleg\\SparqlT.g:43:5: ( ^( PROLOGUE ( baseDecl )* ( prefixDecl )* ) )
 617  
             // com\\googlecode\\sparkleg\\SparqlT.g:43:7: ^( PROLOGUE ( baseDecl )* ( prefixDecl )* )
 618  
             {
 619  0
             root_0 = (CommonTree)adaptor.nil();
 620  
 
 621  
 
 622  0
             _last = (CommonTree)input.LT(1);
 623  
             {
 624  0
             CommonTree _save_last_1 = _last;
 625  0
             CommonTree _first_1 = null;
 626  0
             CommonTree root_1 = (CommonTree)adaptor.nil();
 627  0
             _last = (CommonTree)input.LT(1);
 628  0
             PROLOGUE10=(CommonTree)match(input,PROLOGUE,FOLLOW_PROLOGUE_in_prologue102); 
 629  0
             PROLOGUE10_tree = (CommonTree)adaptor.dupNode(PROLOGUE10);
 630  
 
 631  
 
 632  0
             root_1 = (CommonTree)adaptor.becomeRoot(PROLOGUE10_tree, root_1);
 633  
 
 634  
 
 635  0
             if ( input.LA(1)==Token.DOWN ) {
 636  0
                 match(input, Token.DOWN, null); 
 637  
                 // com\\googlecode\\sparkleg\\SparqlT.g:43:18: ( baseDecl )*
 638  
                 loop8:
 639  
                 do {
 640  0
                     int alt8=2;
 641  0
                     switch ( input.LA(1) ) {
 642  
                     case BASE:
 643  
                         {
 644  0
                         alt8=1;
 645  
                         }
 646  
                         break;
 647  
 
 648  
                     }
 649  
 
 650  0
                     switch (alt8) {
 651  
                         case 1 :
 652  
                             // com\\googlecode\\sparkleg\\SparqlT.g:43:18: baseDecl
 653  
                             {
 654  0
                             _last = (CommonTree)input.LT(1);
 655  0
                             pushFollow(FOLLOW_baseDecl_in_prologue104);
 656  0
                             baseDecl11=baseDecl();
 657  
 
 658  0
                             state._fsp--;
 659  
 
 660  0
                             adaptor.addChild(root_1, baseDecl11.getTree());
 661  
 
 662  
 
 663  
                             }
 664  0
                             break;
 665  
 
 666  
                         default :
 667  0
                             break loop8;
 668  
                     }
 669  0
                 } while (true);
 670  
 
 671  
 
 672  
                 // com\\googlecode\\sparkleg\\SparqlT.g:43:28: ( prefixDecl )*
 673  
                 loop9:
 674  
                 do {
 675  0
                     int alt9=2;
 676  0
                     switch ( input.LA(1) ) {
 677  
                     case PREFIX:
 678  
                         {
 679  0
                         alt9=1;
 680  
                         }
 681  
                         break;
 682  
 
 683  
                     }
 684  
 
 685  0
                     switch (alt9) {
 686  
                         case 1 :
 687  
                             // com\\googlecode\\sparkleg\\SparqlT.g:43:28: prefixDecl
 688  
                             {
 689  0
                             _last = (CommonTree)input.LT(1);
 690  0
                             pushFollow(FOLLOW_prefixDecl_in_prologue107);
 691  0
                             prefixDecl12=prefixDecl();
 692  
 
 693  0
                             state._fsp--;
 694  
 
 695  0
                             adaptor.addChild(root_1, prefixDecl12.getTree());
 696  
 
 697  
 
 698  
                             }
 699  0
                             break;
 700  
 
 701  
                         default :
 702  0
                             break loop9;
 703  
                     }
 704  0
                 } while (true);
 705  
 
 706  
 
 707  0
                 match(input, Token.UP, null); 
 708  
             }
 709  0
             adaptor.addChild(root_0, root_1);
 710  0
             _last = _save_last_1;
 711  
             }
 712  
 
 713  
 
 714  
             }
 715  
 
 716  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 717  
 
 718  
         }
 719  0
         catch (RecognitionException re) {
 720  0
             reportError(re);
 721  0
             recover(input,re);
 722  
         }
 723  
 
 724  0
         finally {
 725  
                 // do for sure before leaving
 726  0
         }
 727  0
         return retval;
 728  
     }
 729  
     // $ANTLR end "prologue"
 730  
 
 731  
 
 732  0
     public static class baseDecl_return extends TreeRuleReturnScope {
 733  
         CommonTree tree;
 734  0
         public Object getTree() { return tree; }
 735  
     };
 736  
 
 737  
 
 738  
     // $ANTLR start "baseDecl"
 739  
     // com\\googlecode\\sparkleg\\SparqlT.g:46:1: baseDecl : ^( BASE IRI_REF ) ;
 740  
     public final SparqlT.baseDecl_return baseDecl() throws RecognitionException {
 741  0
         SparqlT.baseDecl_return retval = new SparqlT.baseDecl_return();
 742  0
         retval.start = input.LT(1);
 743  
 
 744  
 
 745  0
         CommonTree root_0 = null;
 746  
 
 747  0
         CommonTree _first_0 = null;
 748  0
         CommonTree _last = null;
 749  
 
 750  0
         CommonTree BASE13=null;
 751  0
         CommonTree IRI_REF14=null;
 752  
 
 753  0
         CommonTree BASE13_tree=null;
 754  0
         CommonTree IRI_REF14_tree=null;
 755  
 
 756  
         try {
 757  
             // com\\googlecode\\sparkleg\\SparqlT.g:47:5: ( ^( BASE IRI_REF ) )
 758  
             // com\\googlecode\\sparkleg\\SparqlT.g:47:7: ^( BASE IRI_REF )
 759  
             {
 760  0
             root_0 = (CommonTree)adaptor.nil();
 761  
 
 762  
 
 763  0
             _last = (CommonTree)input.LT(1);
 764  
             {
 765  0
             CommonTree _save_last_1 = _last;
 766  0
             CommonTree _first_1 = null;
 767  0
             CommonTree root_1 = (CommonTree)adaptor.nil();
 768  0
             _last = (CommonTree)input.LT(1);
 769  0
             BASE13=(CommonTree)match(input,BASE,FOLLOW_BASE_in_baseDecl127); 
 770  0
             BASE13_tree = (CommonTree)adaptor.dupNode(BASE13);
 771  
 
 772  
 
 773  0
             root_1 = (CommonTree)adaptor.becomeRoot(BASE13_tree, root_1);
 774  
 
 775  
 
 776  0
             match(input, Token.DOWN, null); 
 777  0
             _last = (CommonTree)input.LT(1);
 778  0
             IRI_REF14=(CommonTree)match(input,IRI_REF,FOLLOW_IRI_REF_in_baseDecl129); 
 779  0
             IRI_REF14_tree = (CommonTree)adaptor.dupNode(IRI_REF14);
 780  
 
 781  
 
 782  0
             adaptor.addChild(root_1, IRI_REF14_tree);
 783  
 
 784  
 
 785  0
             match(input, Token.UP, null); 
 786  0
             adaptor.addChild(root_0, root_1);
 787  0
             _last = _save_last_1;
 788  
             }
 789  
 
 790  
 
 791  
             }
 792  
 
 793  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 794  
 
 795  
         }
 796  0
         catch (RecognitionException re) {
 797  0
             reportError(re);
 798  0
             recover(input,re);
 799  
         }
 800  
 
 801  0
         finally {
 802  
                 // do for sure before leaving
 803  0
         }
 804  0
         return retval;
 805  
     }
 806  
     // $ANTLR end "baseDecl"
 807  
 
 808  
 
 809  0
     public static class prefixDecl_return extends TreeRuleReturnScope {
 810  
         CommonTree tree;
 811  0
         public Object getTree() { return tree; }
 812  
     };
 813  
 
 814  
 
 815  
     // $ANTLR start "prefixDecl"
 816  
     // com\\googlecode\\sparkleg\\SparqlT.g:50:1: prefixDecl : ^( PREFIX PNAME_NS IRI_REF ) ;
 817  
     public final SparqlT.prefixDecl_return prefixDecl() throws RecognitionException {
 818  0
         SparqlT.prefixDecl_return retval = new SparqlT.prefixDecl_return();
 819  0
         retval.start = input.LT(1);
 820  
 
 821  
 
 822  0
         CommonTree root_0 = null;
 823  
 
 824  0
         CommonTree _first_0 = null;
 825  0
         CommonTree _last = null;
 826  
 
 827  0
         CommonTree PREFIX15=null;
 828  0
         CommonTree PNAME_NS16=null;
 829  0
         CommonTree IRI_REF17=null;
 830  
 
 831  0
         CommonTree PREFIX15_tree=null;
 832  0
         CommonTree PNAME_NS16_tree=null;
 833  0
         CommonTree IRI_REF17_tree=null;
 834  
 
 835  
         try {
 836  
             // com\\googlecode\\sparkleg\\SparqlT.g:51:5: ( ^( PREFIX PNAME_NS IRI_REF ) )
 837  
             // com\\googlecode\\sparkleg\\SparqlT.g:51:7: ^( PREFIX PNAME_NS IRI_REF )
 838  
             {
 839  0
             root_0 = (CommonTree)adaptor.nil();
 840  
 
 841  
 
 842  0
             _last = (CommonTree)input.LT(1);
 843  
             {
 844  0
             CommonTree _save_last_1 = _last;
 845  0
             CommonTree _first_1 = null;
 846  0
             CommonTree root_1 = (CommonTree)adaptor.nil();
 847  0
             _last = (CommonTree)input.LT(1);
 848  0
             PREFIX15=(CommonTree)match(input,PREFIX,FOLLOW_PREFIX_in_prefixDecl148); 
 849  0
             PREFIX15_tree = (CommonTree)adaptor.dupNode(PREFIX15);
 850  
 
 851  
 
 852  0
             root_1 = (CommonTree)adaptor.becomeRoot(PREFIX15_tree, root_1);
 853  
 
 854  
 
 855  0
             match(input, Token.DOWN, null); 
 856  0
             _last = (CommonTree)input.LT(1);
 857  0
             PNAME_NS16=(CommonTree)match(input,PNAME_NS,FOLLOW_PNAME_NS_in_prefixDecl150); 
 858  0
             PNAME_NS16_tree = (CommonTree)adaptor.dupNode(PNAME_NS16);
 859  
 
 860  
 
 861  0
             adaptor.addChild(root_1, PNAME_NS16_tree);
 862  
 
 863  
 
 864  0
             _last = (CommonTree)input.LT(1);
 865  0
             IRI_REF17=(CommonTree)match(input,IRI_REF,FOLLOW_IRI_REF_in_prefixDecl152); 
 866  0
             IRI_REF17_tree = (CommonTree)adaptor.dupNode(IRI_REF17);
 867  
 
 868  
 
 869  0
             adaptor.addChild(root_1, IRI_REF17_tree);
 870  
 
 871  
 
 872  0
             match(input, Token.UP, null); 
 873  0
             adaptor.addChild(root_0, root_1);
 874  0
             _last = _save_last_1;
 875  
             }
 876  
 
 877  
 
 878  
             }
 879  
 
 880  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 881  
 
 882  
         }
 883  0
         catch (RecognitionException re) {
 884  0
             reportError(re);
 885  0
             recover(input,re);
 886  
         }
 887  
 
 888  0
         finally {
 889  
                 // do for sure before leaving
 890  0
         }
 891  0
         return retval;
 892  
     }
 893  
     // $ANTLR end "prefixDecl"
 894  
 
 895  
 
 896  0
     public static class selectQuery_return extends TreeRuleReturnScope {
 897  
         CommonTree tree;
 898  0
         public Object getTree() { return tree; }
 899  
     };
 900  
 
 901  
 
 902  
     // $ANTLR start "selectQuery"
 903  
     // com\\googlecode\\sparkleg\\SparqlT.g:54:1: selectQuery : ^( SELECT selectClause ( datasetClause )* ( whereClause )* solutionModifier ) ;
 904  
     public final SparqlT.selectQuery_return selectQuery() throws RecognitionException {
 905  0
         SparqlT.selectQuery_return retval = new SparqlT.selectQuery_return();
 906  0
         retval.start = input.LT(1);
 907  
 
 908  
 
 909  0
         CommonTree root_0 = null;
 910  
 
 911  0
         CommonTree _first_0 = null;
 912  0
         CommonTree _last = null;
 913  
 
 914  0
         CommonTree SELECT18=null;
 915  0
         SparqlT.selectClause_return selectClause19 =null;
 916  
 
 917  0
         SparqlT.datasetClause_return datasetClause20 =null;
 918  
 
 919  0
         SparqlT.whereClause_return whereClause21 =null;
 920  
 
 921  0
         SparqlT.solutionModifier_return solutionModifier22 =null;
 922  
 
 923  
 
 924  0
         CommonTree SELECT18_tree=null;
 925  
 
 926  
         try {
 927  
             // com\\googlecode\\sparkleg\\SparqlT.g:55:5: ( ^( SELECT selectClause ( datasetClause )* ( whereClause )* solutionModifier ) )
 928  
             // com\\googlecode\\sparkleg\\SparqlT.g:55:7: ^( SELECT selectClause ( datasetClause )* ( whereClause )* solutionModifier )
 929  
             {
 930  0
             root_0 = (CommonTree)adaptor.nil();
 931  
 
 932  
 
 933  0
             _last = (CommonTree)input.LT(1);
 934  
             {
 935  0
             CommonTree _save_last_1 = _last;
 936  0
             CommonTree _first_1 = null;
 937  0
             CommonTree root_1 = (CommonTree)adaptor.nil();
 938  0
             _last = (CommonTree)input.LT(1);
 939  0
             SELECT18=(CommonTree)match(input,SELECT,FOLLOW_SELECT_in_selectQuery171); 
 940  0
             SELECT18_tree = (CommonTree)adaptor.dupNode(SELECT18);
 941  
 
 942  
 
 943  0
             root_1 = (CommonTree)adaptor.becomeRoot(SELECT18_tree, root_1);
 944  
 
 945  
 
 946  0
             match(input, Token.DOWN, null); 
 947  0
             _last = (CommonTree)input.LT(1);
 948  0
             pushFollow(FOLLOW_selectClause_in_selectQuery173);
 949  0
             selectClause19=selectClause();
 950  
 
 951  0
             state._fsp--;
 952  
 
 953  0
             adaptor.addChild(root_1, selectClause19.getTree());
 954  
 
 955  
 
 956  
             // com\\googlecode\\sparkleg\\SparqlT.g:55:29: ( datasetClause )*
 957  
             loop10:
 958  
             do {
 959  0
                 int alt10=2;
 960  0
                 switch ( input.LA(1) ) {
 961  
                 case FROM:
 962  
                     {
 963  0
                     alt10=1;
 964  
                     }
 965  
                     break;
 966  
 
 967  
                 }
 968  
 
 969  0
                 switch (alt10) {
 970  
                     case 1 :
 971  
                         // com\\googlecode\\sparkleg\\SparqlT.g:55:29: datasetClause
 972  
                         {
 973  0
                         _last = (CommonTree)input.LT(1);
 974  0
                         pushFollow(FOLLOW_datasetClause_in_selectQuery175);
 975  0
                         datasetClause20=datasetClause();
 976  
 
 977  0
                         state._fsp--;
 978  
 
 979  0
                         adaptor.addChild(root_1, datasetClause20.getTree());
 980  
 
 981  
 
 982  
                         }
 983  0
                         break;
 984  
 
 985  
                     default :
 986  0
                         break loop10;
 987  
                 }
 988  0
             } while (true);
 989  
 
 990  
 
 991  
             // com\\googlecode\\sparkleg\\SparqlT.g:55:44: ( whereClause )*
 992  
             loop11:
 993  
             do {
 994  0
                 int alt11=2;
 995  0
                 switch ( input.LA(1) ) {
 996  
                 case WHERE_CLAUSE:
 997  
                     {
 998  0
                     alt11=1;
 999  
                     }
 1000  
                     break;
 1001  
 
 1002  
                 }
 1003  
 
 1004  0
                 switch (alt11) {
 1005  
                     case 1 :
 1006  
                         // com\\googlecode\\sparkleg\\SparqlT.g:55:44: whereClause
 1007  
                         {
 1008  0
                         _last = (CommonTree)input.LT(1);
 1009  0
                         pushFollow(FOLLOW_whereClause_in_selectQuery178);
 1010  0
                         whereClause21=whereClause();
 1011  
 
 1012  0
                         state._fsp--;
 1013  
 
 1014  0
                         adaptor.addChild(root_1, whereClause21.getTree());
 1015  
 
 1016  
 
 1017  
                         }
 1018  0
                         break;
 1019  
 
 1020  
                     default :
 1021  0
                         break loop11;
 1022  
                 }
 1023  0
             } while (true);
 1024  
 
 1025  
 
 1026  0
             _last = (CommonTree)input.LT(1);
 1027  0
             pushFollow(FOLLOW_solutionModifier_in_selectQuery181);
 1028  0
             solutionModifier22=solutionModifier();
 1029  
 
 1030  0
             state._fsp--;
 1031  
 
 1032  0
             adaptor.addChild(root_1, solutionModifier22.getTree());
 1033  
 
 1034  
 
 1035  0
             match(input, Token.UP, null); 
 1036  0
             adaptor.addChild(root_0, root_1);
 1037  0
             _last = _save_last_1;
 1038  
             }
 1039  
 
 1040  
 
 1041  
             }
 1042  
 
 1043  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 1044  
 
 1045  
         }
 1046  0
         catch (RecognitionException re) {
 1047  0
             reportError(re);
 1048  0
             recover(input,re);
 1049  
         }
 1050  
 
 1051  0
         finally {
 1052  
                 // do for sure before leaving
 1053  0
         }
 1054  0
         return retval;
 1055  
     }
 1056  
     // $ANTLR end "selectQuery"
 1057  
 
 1058  
 
 1059  0
     public static class subSelect_return extends TreeRuleReturnScope {
 1060  
         CommonTree tree;
 1061  0
         public Object getTree() { return tree; }
 1062  
     };
 1063  
 
 1064  
 
 1065  
     // $ANTLR start "subSelect"
 1066  
     // com\\googlecode\\sparkleg\\SparqlT.g:58:1: subSelect : ^( SUBSELECT ( whereClause )* ( datasetClause )* solutionModifier ) ;
 1067  
     public final SparqlT.subSelect_return subSelect() throws RecognitionException {
 1068  0
         SparqlT.subSelect_return retval = new SparqlT.subSelect_return();
 1069  0
         retval.start = input.LT(1);
 1070  
 
 1071  
 
 1072  0
         CommonTree root_0 = null;
 1073  
 
 1074  0
         CommonTree _first_0 = null;
 1075  0
         CommonTree _last = null;
 1076  
 
 1077  0
         CommonTree SUBSELECT23=null;
 1078  0
         SparqlT.whereClause_return whereClause24 =null;
 1079  
 
 1080  0
         SparqlT.datasetClause_return datasetClause25 =null;
 1081  
 
 1082  0
         SparqlT.solutionModifier_return solutionModifier26 =null;
 1083  
 
 1084  
 
 1085  0
         CommonTree SUBSELECT23_tree=null;
 1086  
 
 1087  
         try {
 1088  
             // com\\googlecode\\sparkleg\\SparqlT.g:59:5: ( ^( SUBSELECT ( whereClause )* ( datasetClause )* solutionModifier ) )
 1089  
             // com\\googlecode\\sparkleg\\SparqlT.g:59:7: ^( SUBSELECT ( whereClause )* ( datasetClause )* solutionModifier )
 1090  
             {
 1091  0
             root_0 = (CommonTree)adaptor.nil();
 1092  
 
 1093  
 
 1094  0
             _last = (CommonTree)input.LT(1);
 1095  
             {
 1096  0
             CommonTree _save_last_1 = _last;
 1097  0
             CommonTree _first_1 = null;
 1098  0
             CommonTree root_1 = (CommonTree)adaptor.nil();
 1099  0
             _last = (CommonTree)input.LT(1);
 1100  0
             SUBSELECT23=(CommonTree)match(input,SUBSELECT,FOLLOW_SUBSELECT_in_subSelect200); 
 1101  0
             SUBSELECT23_tree = (CommonTree)adaptor.dupNode(SUBSELECT23);
 1102  
 
 1103  
 
 1104  0
             root_1 = (CommonTree)adaptor.becomeRoot(SUBSELECT23_tree, root_1);
 1105  
 
 1106  
 
 1107  0
             if ( input.LA(1)==Token.DOWN ) {
 1108  0
                 match(input, Token.DOWN, null); 
 1109  
                 // com\\googlecode\\sparkleg\\SparqlT.g:59:19: ( whereClause )*
 1110  
                 loop12:
 1111  
                 do {
 1112  0
                     int alt12=2;
 1113  0
                     switch ( input.LA(1) ) {
 1114  
                     case WHERE_CLAUSE:
 1115  
                         {
 1116  0
                         alt12=1;
 1117  
                         }
 1118  
                         break;
 1119  
 
 1120  
                     }
 1121  
 
 1122  0
                     switch (alt12) {
 1123  
                         case 1 :
 1124  
                             // com\\googlecode\\sparkleg\\SparqlT.g:59:19: whereClause
 1125  
                             {
 1126  0
                             _last = (CommonTree)input.LT(1);
 1127  0
                             pushFollow(FOLLOW_whereClause_in_subSelect202);
 1128  0
                             whereClause24=whereClause();
 1129  
 
 1130  0
                             state._fsp--;
 1131  
 
 1132  0
                             adaptor.addChild(root_1, whereClause24.getTree());
 1133  
 
 1134  
 
 1135  
                             }
 1136  0
                             break;
 1137  
 
 1138  
                         default :
 1139  0
                             break loop12;
 1140  
                     }
 1141  0
                 } while (true);
 1142  
 
 1143  
 
 1144  
                 // com\\googlecode\\sparkleg\\SparqlT.g:59:32: ( datasetClause )*
 1145  
                 loop13:
 1146  
                 do {
 1147  0
                     int alt13=2;
 1148  0
                     switch ( input.LA(1) ) {
 1149  
                     case FROM:
 1150  
                         {
 1151  0
                         alt13=1;
 1152  
                         }
 1153  
                         break;
 1154  
 
 1155  
                     }
 1156  
 
 1157  0
                     switch (alt13) {
 1158  
                         case 1 :
 1159  
                             // com\\googlecode\\sparkleg\\SparqlT.g:59:32: datasetClause
 1160  
                             {
 1161  0
                             _last = (CommonTree)input.LT(1);
 1162  0
                             pushFollow(FOLLOW_datasetClause_in_subSelect205);
 1163  0
                             datasetClause25=datasetClause();
 1164  
 
 1165  0
                             state._fsp--;
 1166  
 
 1167  0
                             adaptor.addChild(root_1, datasetClause25.getTree());
 1168  
 
 1169  
 
 1170  
                             }
 1171  0
                             break;
 1172  
 
 1173  
                         default :
 1174  0
                             break loop13;
 1175  
                     }
 1176  0
                 } while (true);
 1177  
 
 1178  
 
 1179  0
                 _last = (CommonTree)input.LT(1);
 1180  0
                 pushFollow(FOLLOW_solutionModifier_in_subSelect208);
 1181  0
                 solutionModifier26=solutionModifier();
 1182  
 
 1183  0
                 state._fsp--;
 1184  
 
 1185  0
                 adaptor.addChild(root_1, solutionModifier26.getTree());
 1186  
 
 1187  
 
 1188  0
                 match(input, Token.UP, null); 
 1189  
             }
 1190  0
             adaptor.addChild(root_0, root_1);
 1191  0
             _last = _save_last_1;
 1192  
             }
 1193  
 
 1194  
 
 1195  
             }
 1196  
 
 1197  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 1198  
 
 1199  
         }
 1200  0
         catch (RecognitionException re) {
 1201  0
             reportError(re);
 1202  0
             recover(input,re);
 1203  
         }
 1204  
 
 1205  0
         finally {
 1206  
                 // do for sure before leaving
 1207  0
         }
 1208  0
         return retval;
 1209  
     }
 1210  
     // $ANTLR end "subSelect"
 1211  
 
 1212  
 
 1213  0
     public static class selectClause_return extends TreeRuleReturnScope {
 1214  
         CommonTree tree;
 1215  0
         public Object getTree() { return tree; }
 1216  
     };
 1217  
 
 1218  
 
 1219  
     // $ANTLR start "selectClause"
 1220  
     // com\\googlecode\\sparkleg\\SparqlT.g:62:1: selectClause : ( ^( SELECT_CLAUSE ASTERISK ) | ^( SELECT_CLAUSE DISTINCT ASTERISK ) | ^( SELECT_CLAUSE REDUCED ASTERISK ) | ^( SELECT_CLAUSE ( selectVariables )* ) | ^( SELECT_CLAUSE DISTINCT ( selectVariables )* ) | ^( SELECT_CLAUSE REDUCED ( selectVariables )* ) );
 1221  
     public final SparqlT.selectClause_return selectClause() throws RecognitionException {
 1222  0
         SparqlT.selectClause_return retval = new SparqlT.selectClause_return();
 1223  0
         retval.start = input.LT(1);
 1224  
 
 1225  
 
 1226  0
         CommonTree root_0 = null;
 1227  
 
 1228  0
         CommonTree _first_0 = null;
 1229  0
         CommonTree _last = null;
 1230  
 
 1231  0
         CommonTree SELECT_CLAUSE27=null;
 1232  0
         CommonTree ASTERISK28=null;
 1233  0
         CommonTree SELECT_CLAUSE29=null;
 1234  0
         CommonTree DISTINCT30=null;
 1235  0
         CommonTree ASTERISK31=null;
 1236  0
         CommonTree SELECT_CLAUSE32=null;
 1237  0
         CommonTree REDUCED33=null;
 1238  0
         CommonTree ASTERISK34=null;
 1239  0
         CommonTree SELECT_CLAUSE35=null;
 1240  0
         CommonTree SELECT_CLAUSE37=null;
 1241  0
         CommonTree DISTINCT38=null;
 1242  0
         CommonTree SELECT_CLAUSE40=null;
 1243  0
         CommonTree REDUCED41=null;
 1244  0
         SparqlT.selectVariables_return selectVariables36 =null;
 1245  
 
 1246  0
         SparqlT.selectVariables_return selectVariables39 =null;
 1247  
 
 1248  0
         SparqlT.selectVariables_return selectVariables42 =null;
 1249  
 
 1250  
 
 1251  0
         CommonTree SELECT_CLAUSE27_tree=null;
 1252  0
         CommonTree ASTERISK28_tree=null;
 1253  0
         CommonTree SELECT_CLAUSE29_tree=null;
 1254  0
         CommonTree DISTINCT30_tree=null;
 1255  0
         CommonTree ASTERISK31_tree=null;
 1256  0
         CommonTree SELECT_CLAUSE32_tree=null;
 1257  0
         CommonTree REDUCED33_tree=null;
 1258  0
         CommonTree ASTERISK34_tree=null;
 1259  0
         CommonTree SELECT_CLAUSE35_tree=null;
 1260  0
         CommonTree SELECT_CLAUSE37_tree=null;
 1261  0
         CommonTree DISTINCT38_tree=null;
 1262  0
         CommonTree SELECT_CLAUSE40_tree=null;
 1263  0
         CommonTree REDUCED41_tree=null;
 1264  
 
 1265  
         try {
 1266  
             // com\\googlecode\\sparkleg\\SparqlT.g:63:5: ( ^( SELECT_CLAUSE ASTERISK ) | ^( SELECT_CLAUSE DISTINCT ASTERISK ) | ^( SELECT_CLAUSE REDUCED ASTERISK ) | ^( SELECT_CLAUSE ( selectVariables )* ) | ^( SELECT_CLAUSE DISTINCT ( selectVariables )* ) | ^( SELECT_CLAUSE REDUCED ( selectVariables )* ) )
 1267  0
             int alt17=6;
 1268  0
             switch ( input.LA(1) ) {
 1269  
             case SELECT_CLAUSE:
 1270  
                 {
 1271  0
                 switch ( input.LA(2) ) {
 1272  
                 case DOWN:
 1273  
                     {
 1274  0
                     switch ( input.LA(3) ) {
 1275  
                     case ASTERISK:
 1276  
                         {
 1277  0
                         alt17=1;
 1278  
                         }
 1279  0
                         break;
 1280  
                     case DISTINCT:
 1281  
                         {
 1282  0
                         switch ( input.LA(4) ) {
 1283  
                         case ASTERISK:
 1284  
                             {
 1285  0
                             alt17=2;
 1286  
                             }
 1287  0
                             break;
 1288  
                         case UP:
 1289  
                         case AS:
 1290  
                         case VAR:
 1291  
                             {
 1292  0
                             alt17=5;
 1293  
                             }
 1294  0
                             break;
 1295  
                         default:
 1296  0
                             NoViableAltException nvae =
 1297  
                                 new NoViableAltException("", 17, 4, input);
 1298  
 
 1299  0
                             throw nvae;
 1300  
 
 1301  
                         }
 1302  
 
 1303  
                         }
 1304  0
                         break;
 1305  
                     case REDUCED:
 1306  
                         {
 1307  0
                         switch ( input.LA(4) ) {
 1308  
                         case ASTERISK:
 1309  
                             {
 1310  0
                             alt17=3;
 1311  
                             }
 1312  0
                             break;
 1313  
                         case UP:
 1314  
                         case AS:
 1315  
                         case VAR:
 1316  
                             {
 1317  0
                             alt17=6;
 1318  
                             }
 1319  0
                             break;
 1320  
                         default:
 1321  0
                             NoViableAltException nvae =
 1322  
                                 new NoViableAltException("", 17, 5, input);
 1323  
 
 1324  0
                             throw nvae;
 1325  
 
 1326  
                         }
 1327  
 
 1328  
                         }
 1329  0
                         break;
 1330  
                     case UP:
 1331  
                     case AS:
 1332  
                     case VAR:
 1333  
                         {
 1334  0
                         alt17=4;
 1335  
                         }
 1336  0
                         break;
 1337  
                     default:
 1338  0
                         NoViableAltException nvae =
 1339  
                             new NoViableAltException("", 17, 2, input);
 1340  
 
 1341  0
                         throw nvae;
 1342  
 
 1343  
                     }
 1344  
 
 1345  
                     }
 1346  0
                     break;
 1347  
                 default:
 1348  0
                     NoViableAltException nvae =
 1349  
                         new NoViableAltException("", 17, 1, input);
 1350  
 
 1351  0
                     throw nvae;
 1352  
 
 1353  
                 }
 1354  
 
 1355  
                 }
 1356  0
                 break;
 1357  
             default:
 1358  0
                 NoViableAltException nvae =
 1359  
                     new NoViableAltException("", 17, 0, input);
 1360  
 
 1361  0
                 throw nvae;
 1362  
 
 1363  
             }
 1364  
 
 1365  0
             switch (alt17) {
 1366  
                 case 1 :
 1367  
                     // com\\googlecode\\sparkleg\\SparqlT.g:63:7: ^( SELECT_CLAUSE ASTERISK )
 1368  
                     {
 1369  0
                     root_0 = (CommonTree)adaptor.nil();
 1370  
 
 1371  
 
 1372  0
                     _last = (CommonTree)input.LT(1);
 1373  
                     {
 1374  0
                     CommonTree _save_last_1 = _last;
 1375  0
                     CommonTree _first_1 = null;
 1376  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 1377  0
                     _last = (CommonTree)input.LT(1);
 1378  0
                     SELECT_CLAUSE27=(CommonTree)match(input,SELECT_CLAUSE,FOLLOW_SELECT_CLAUSE_in_selectClause232); 
 1379  0
                     SELECT_CLAUSE27_tree = (CommonTree)adaptor.dupNode(SELECT_CLAUSE27);
 1380  
 
 1381  
 
 1382  0
                     root_1 = (CommonTree)adaptor.becomeRoot(SELECT_CLAUSE27_tree, root_1);
 1383  
 
 1384  
 
 1385  0
                     match(input, Token.DOWN, null); 
 1386  0
                     _last = (CommonTree)input.LT(1);
 1387  0
                     ASTERISK28=(CommonTree)match(input,ASTERISK,FOLLOW_ASTERISK_in_selectClause234); 
 1388  0
                     ASTERISK28_tree = (CommonTree)adaptor.dupNode(ASTERISK28);
 1389  
 
 1390  
 
 1391  0
                     adaptor.addChild(root_1, ASTERISK28_tree);
 1392  
 
 1393  
 
 1394  0
                     match(input, Token.UP, null); 
 1395  0
                     adaptor.addChild(root_0, root_1);
 1396  0
                     _last = _save_last_1;
 1397  
                     }
 1398  
 
 1399  
 
 1400  
                     }
 1401  0
                     break;
 1402  
                 case 2 :
 1403  
                     // com\\googlecode\\sparkleg\\SparqlT.g:64:7: ^( SELECT_CLAUSE DISTINCT ASTERISK )
 1404  
                     {
 1405  0
                     root_0 = (CommonTree)adaptor.nil();
 1406  
 
 1407  
 
 1408  0
                     _last = (CommonTree)input.LT(1);
 1409  
                     {
 1410  0
                     CommonTree _save_last_1 = _last;
 1411  0
                     CommonTree _first_1 = null;
 1412  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 1413  0
                     _last = (CommonTree)input.LT(1);
 1414  0
                     SELECT_CLAUSE29=(CommonTree)match(input,SELECT_CLAUSE,FOLLOW_SELECT_CLAUSE_in_selectClause244); 
 1415  0
                     SELECT_CLAUSE29_tree = (CommonTree)adaptor.dupNode(SELECT_CLAUSE29);
 1416  
 
 1417  
 
 1418  0
                     root_1 = (CommonTree)adaptor.becomeRoot(SELECT_CLAUSE29_tree, root_1);
 1419  
 
 1420  
 
 1421  0
                     match(input, Token.DOWN, null); 
 1422  0
                     _last = (CommonTree)input.LT(1);
 1423  0
                     DISTINCT30=(CommonTree)match(input,DISTINCT,FOLLOW_DISTINCT_in_selectClause246); 
 1424  0
                     DISTINCT30_tree = (CommonTree)adaptor.dupNode(DISTINCT30);
 1425  
 
 1426  
 
 1427  0
                     adaptor.addChild(root_1, DISTINCT30_tree);
 1428  
 
 1429  
 
 1430  0
                     _last = (CommonTree)input.LT(1);
 1431  0
                     ASTERISK31=(CommonTree)match(input,ASTERISK,FOLLOW_ASTERISK_in_selectClause248); 
 1432  0
                     ASTERISK31_tree = (CommonTree)adaptor.dupNode(ASTERISK31);
 1433  
 
 1434  
 
 1435  0
                     adaptor.addChild(root_1, ASTERISK31_tree);
 1436  
 
 1437  
 
 1438  0
                     match(input, Token.UP, null); 
 1439  0
                     adaptor.addChild(root_0, root_1);
 1440  0
                     _last = _save_last_1;
 1441  
                     }
 1442  
 
 1443  
 
 1444  
                     }
 1445  0
                     break;
 1446  
                 case 3 :
 1447  
                     // com\\googlecode\\sparkleg\\SparqlT.g:65:7: ^( SELECT_CLAUSE REDUCED ASTERISK )
 1448  
                     {
 1449  0
                     root_0 = (CommonTree)adaptor.nil();
 1450  
 
 1451  
 
 1452  0
                     _last = (CommonTree)input.LT(1);
 1453  
                     {
 1454  0
                     CommonTree _save_last_1 = _last;
 1455  0
                     CommonTree _first_1 = null;
 1456  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 1457  0
                     _last = (CommonTree)input.LT(1);
 1458  0
                     SELECT_CLAUSE32=(CommonTree)match(input,SELECT_CLAUSE,FOLLOW_SELECT_CLAUSE_in_selectClause258); 
 1459  0
                     SELECT_CLAUSE32_tree = (CommonTree)adaptor.dupNode(SELECT_CLAUSE32);
 1460  
 
 1461  
 
 1462  0
                     root_1 = (CommonTree)adaptor.becomeRoot(SELECT_CLAUSE32_tree, root_1);
 1463  
 
 1464  
 
 1465  0
                     match(input, Token.DOWN, null); 
 1466  0
                     _last = (CommonTree)input.LT(1);
 1467  0
                     REDUCED33=(CommonTree)match(input,REDUCED,FOLLOW_REDUCED_in_selectClause260); 
 1468  0
                     REDUCED33_tree = (CommonTree)adaptor.dupNode(REDUCED33);
 1469  
 
 1470  
 
 1471  0
                     adaptor.addChild(root_1, REDUCED33_tree);
 1472  
 
 1473  
 
 1474  0
                     _last = (CommonTree)input.LT(1);
 1475  0
                     ASTERISK34=(CommonTree)match(input,ASTERISK,FOLLOW_ASTERISK_in_selectClause262); 
 1476  0
                     ASTERISK34_tree = (CommonTree)adaptor.dupNode(ASTERISK34);
 1477  
 
 1478  
 
 1479  0
                     adaptor.addChild(root_1, ASTERISK34_tree);
 1480  
 
 1481  
 
 1482  0
                     match(input, Token.UP, null); 
 1483  0
                     adaptor.addChild(root_0, root_1);
 1484  0
                     _last = _save_last_1;
 1485  
                     }
 1486  
 
 1487  
 
 1488  
                     }
 1489  0
                     break;
 1490  
                 case 4 :
 1491  
                     // com\\googlecode\\sparkleg\\SparqlT.g:66:7: ^( SELECT_CLAUSE ( selectVariables )* )
 1492  
                     {
 1493  0
                     root_0 = (CommonTree)adaptor.nil();
 1494  
 
 1495  
 
 1496  0
                     _last = (CommonTree)input.LT(1);
 1497  
                     {
 1498  0
                     CommonTree _save_last_1 = _last;
 1499  0
                     CommonTree _first_1 = null;
 1500  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 1501  0
                     _last = (CommonTree)input.LT(1);
 1502  0
                     SELECT_CLAUSE35=(CommonTree)match(input,SELECT_CLAUSE,FOLLOW_SELECT_CLAUSE_in_selectClause272); 
 1503  0
                     SELECT_CLAUSE35_tree = (CommonTree)adaptor.dupNode(SELECT_CLAUSE35);
 1504  
 
 1505  
 
 1506  0
                     root_1 = (CommonTree)adaptor.becomeRoot(SELECT_CLAUSE35_tree, root_1);
 1507  
 
 1508  
 
 1509  0
                     if ( input.LA(1)==Token.DOWN ) {
 1510  0
                         match(input, Token.DOWN, null); 
 1511  
                         // com\\googlecode\\sparkleg\\SparqlT.g:66:23: ( selectVariables )*
 1512  
                         loop14:
 1513  
                         do {
 1514  0
                             int alt14=2;
 1515  0
                             switch ( input.LA(1) ) {
 1516  
                             case AS:
 1517  
                             case VAR:
 1518  
                                 {
 1519  0
                                 alt14=1;
 1520  
                                 }
 1521  
                                 break;
 1522  
 
 1523  
                             }
 1524  
 
 1525  0
                             switch (alt14) {
 1526  
                                 case 1 :
 1527  
                                     // com\\googlecode\\sparkleg\\SparqlT.g:66:23: selectVariables
 1528  
                                     {
 1529  0
                                     _last = (CommonTree)input.LT(1);
 1530  0
                                     pushFollow(FOLLOW_selectVariables_in_selectClause274);
 1531  0
                                     selectVariables36=selectVariables();
 1532  
 
 1533  0
                                     state._fsp--;
 1534  
 
 1535  0
                                     adaptor.addChild(root_1, selectVariables36.getTree());
 1536  
 
 1537  
 
 1538  
                                     }
 1539  0
                                     break;
 1540  
 
 1541  
                                 default :
 1542  0
                                     break loop14;
 1543  
                             }
 1544  0
                         } while (true);
 1545  
 
 1546  
 
 1547  0
                         match(input, Token.UP, null); 
 1548  
                     }
 1549  0
                     adaptor.addChild(root_0, root_1);
 1550  0
                     _last = _save_last_1;
 1551  
                     }
 1552  
 
 1553  
 
 1554  
                     }
 1555  0
                     break;
 1556  
                 case 5 :
 1557  
                     // com\\googlecode\\sparkleg\\SparqlT.g:67:7: ^( SELECT_CLAUSE DISTINCT ( selectVariables )* )
 1558  
                     {
 1559  0
                     root_0 = (CommonTree)adaptor.nil();
 1560  
 
 1561  
 
 1562  0
                     _last = (CommonTree)input.LT(1);
 1563  
                     {
 1564  0
                     CommonTree _save_last_1 = _last;
 1565  0
                     CommonTree _first_1 = null;
 1566  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 1567  0
                     _last = (CommonTree)input.LT(1);
 1568  0
                     SELECT_CLAUSE37=(CommonTree)match(input,SELECT_CLAUSE,FOLLOW_SELECT_CLAUSE_in_selectClause285); 
 1569  0
                     SELECT_CLAUSE37_tree = (CommonTree)adaptor.dupNode(SELECT_CLAUSE37);
 1570  
 
 1571  
 
 1572  0
                     root_1 = (CommonTree)adaptor.becomeRoot(SELECT_CLAUSE37_tree, root_1);
 1573  
 
 1574  
 
 1575  0
                     match(input, Token.DOWN, null); 
 1576  0
                     _last = (CommonTree)input.LT(1);
 1577  0
                     DISTINCT38=(CommonTree)match(input,DISTINCT,FOLLOW_DISTINCT_in_selectClause287); 
 1578  0
                     DISTINCT38_tree = (CommonTree)adaptor.dupNode(DISTINCT38);
 1579  
 
 1580  
 
 1581  0
                     adaptor.addChild(root_1, DISTINCT38_tree);
 1582  
 
 1583  
 
 1584  
                     // com\\googlecode\\sparkleg\\SparqlT.g:67:32: ( selectVariables )*
 1585  
                     loop15:
 1586  
                     do {
 1587  0
                         int alt15=2;
 1588  0
                         switch ( input.LA(1) ) {
 1589  
                         case AS:
 1590  
                         case VAR:
 1591  
                             {
 1592  0
                             alt15=1;
 1593  
                             }
 1594  
                             break;
 1595  
 
 1596  
                         }
 1597  
 
 1598  0
                         switch (alt15) {
 1599  
                             case 1 :
 1600  
                                 // com\\googlecode\\sparkleg\\SparqlT.g:67:32: selectVariables
 1601  
                                 {
 1602  0
                                 _last = (CommonTree)input.LT(1);
 1603  0
                                 pushFollow(FOLLOW_selectVariables_in_selectClause289);
 1604  0
                                 selectVariables39=selectVariables();
 1605  
 
 1606  0
                                 state._fsp--;
 1607  
 
 1608  0
                                 adaptor.addChild(root_1, selectVariables39.getTree());
 1609  
 
 1610  
 
 1611  
                                 }
 1612  0
                                 break;
 1613  
 
 1614  
                             default :
 1615  0
                                 break loop15;
 1616  
                         }
 1617  0
                     } while (true);
 1618  
 
 1619  
 
 1620  0
                     match(input, Token.UP, null); 
 1621  0
                     adaptor.addChild(root_0, root_1);
 1622  0
                     _last = _save_last_1;
 1623  
                     }
 1624  
 
 1625  
 
 1626  
                     }
 1627  0
                     break;
 1628  
                 case 6 :
 1629  
                     // com\\googlecode\\sparkleg\\SparqlT.g:68:7: ^( SELECT_CLAUSE REDUCED ( selectVariables )* )
 1630  
                     {
 1631  0
                     root_0 = (CommonTree)adaptor.nil();
 1632  
 
 1633  
 
 1634  0
                     _last = (CommonTree)input.LT(1);
 1635  
                     {
 1636  0
                     CommonTree _save_last_1 = _last;
 1637  0
                     CommonTree _first_1 = null;
 1638  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 1639  0
                     _last = (CommonTree)input.LT(1);
 1640  0
                     SELECT_CLAUSE40=(CommonTree)match(input,SELECT_CLAUSE,FOLLOW_SELECT_CLAUSE_in_selectClause300); 
 1641  0
                     SELECT_CLAUSE40_tree = (CommonTree)adaptor.dupNode(SELECT_CLAUSE40);
 1642  
 
 1643  
 
 1644  0
                     root_1 = (CommonTree)adaptor.becomeRoot(SELECT_CLAUSE40_tree, root_1);
 1645  
 
 1646  
 
 1647  0
                     match(input, Token.DOWN, null); 
 1648  0
                     _last = (CommonTree)input.LT(1);
 1649  0
                     REDUCED41=(CommonTree)match(input,REDUCED,FOLLOW_REDUCED_in_selectClause302); 
 1650  0
                     REDUCED41_tree = (CommonTree)adaptor.dupNode(REDUCED41);
 1651  
 
 1652  
 
 1653  0
                     adaptor.addChild(root_1, REDUCED41_tree);
 1654  
 
 1655  
 
 1656  
                     // com\\googlecode\\sparkleg\\SparqlT.g:68:31: ( selectVariables )*
 1657  
                     loop16:
 1658  
                     do {
 1659  0
                         int alt16=2;
 1660  0
                         switch ( input.LA(1) ) {
 1661  
                         case AS:
 1662  
                         case VAR:
 1663  
                             {
 1664  0
                             alt16=1;
 1665  
                             }
 1666  
                             break;
 1667  
 
 1668  
                         }
 1669  
 
 1670  0
                         switch (alt16) {
 1671  
                             case 1 :
 1672  
                                 // com\\googlecode\\sparkleg\\SparqlT.g:68:31: selectVariables
 1673  
                                 {
 1674  0
                                 _last = (CommonTree)input.LT(1);
 1675  0
                                 pushFollow(FOLLOW_selectVariables_in_selectClause304);
 1676  0
                                 selectVariables42=selectVariables();
 1677  
 
 1678  0
                                 state._fsp--;
 1679  
 
 1680  0
                                 adaptor.addChild(root_1, selectVariables42.getTree());
 1681  
 
 1682  
 
 1683  
                                 }
 1684  0
                                 break;
 1685  
 
 1686  
                             default :
 1687  0
                                 break loop16;
 1688  
                         }
 1689  0
                     } while (true);
 1690  
 
 1691  
 
 1692  0
                     match(input, Token.UP, null); 
 1693  0
                     adaptor.addChild(root_0, root_1);
 1694  0
                     _last = _save_last_1;
 1695  
                     }
 1696  
 
 1697  
 
 1698  
                     }
 1699  
                     break;
 1700  
 
 1701  
             }
 1702  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 1703  
 
 1704  
         }
 1705  0
         catch (RecognitionException re) {
 1706  0
             reportError(re);
 1707  0
             recover(input,re);
 1708  
         }
 1709  
 
 1710  0
         finally {
 1711  
                 // do for sure before leaving
 1712  0
         }
 1713  0
         return retval;
 1714  
     }
 1715  
     // $ANTLR end "selectClause"
 1716  
 
 1717  
 
 1718  0
     public static class selectVariables_return extends TreeRuleReturnScope {
 1719  
         CommonTree tree;
 1720  0
         public Object getTree() { return tree; }
 1721  
     };
 1722  
 
 1723  
 
 1724  
     // $ANTLR start "selectVariables"
 1725  
     // com\\googlecode\\sparkleg\\SparqlT.g:71:1: selectVariables : ( ^( VAR var ) | ^( AS expression var ) );
 1726  
     public final SparqlT.selectVariables_return selectVariables() throws RecognitionException {
 1727  0
         SparqlT.selectVariables_return retval = new SparqlT.selectVariables_return();
 1728  0
         retval.start = input.LT(1);
 1729  
 
 1730  
 
 1731  0
         CommonTree root_0 = null;
 1732  
 
 1733  0
         CommonTree _first_0 = null;
 1734  0
         CommonTree _last = null;
 1735  
 
 1736  0
         CommonTree VAR43=null;
 1737  0
         CommonTree AS45=null;
 1738  0
         SparqlT.var_return var44 =null;
 1739  
 
 1740  0
         SparqlT.expression_return expression46 =null;
 1741  
 
 1742  0
         SparqlT.var_return var47 =null;
 1743  
 
 1744  
 
 1745  0
         CommonTree VAR43_tree=null;
 1746  0
         CommonTree AS45_tree=null;
 1747  
 
 1748  
         try {
 1749  
             // com\\googlecode\\sparkleg\\SparqlT.g:72:5: ( ^( VAR var ) | ^( AS expression var ) )
 1750  0
             int alt18=2;
 1751  0
             switch ( input.LA(1) ) {
 1752  
             case VAR:
 1753  
                 {
 1754  0
                 alt18=1;
 1755  
                 }
 1756  0
                 break;
 1757  
             case AS:
 1758  
                 {
 1759  0
                 alt18=2;
 1760  
                 }
 1761  0
                 break;
 1762  
             default:
 1763  0
                 NoViableAltException nvae =
 1764  
                     new NoViableAltException("", 18, 0, input);
 1765  
 
 1766  0
                 throw nvae;
 1767  
 
 1768  
             }
 1769  
 
 1770  0
             switch (alt18) {
 1771  
                 case 1 :
 1772  
                     // com\\googlecode\\sparkleg\\SparqlT.g:72:7: ^( VAR var )
 1773  
                     {
 1774  0
                     root_0 = (CommonTree)adaptor.nil();
 1775  
 
 1776  
 
 1777  0
                     _last = (CommonTree)input.LT(1);
 1778  
                     {
 1779  0
                     CommonTree _save_last_1 = _last;
 1780  0
                     CommonTree _first_1 = null;
 1781  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 1782  0
                     _last = (CommonTree)input.LT(1);
 1783  0
                     VAR43=(CommonTree)match(input,VAR,FOLLOW_VAR_in_selectVariables324); 
 1784  0
                     VAR43_tree = (CommonTree)adaptor.dupNode(VAR43);
 1785  
 
 1786  
 
 1787  0
                     root_1 = (CommonTree)adaptor.becomeRoot(VAR43_tree, root_1);
 1788  
 
 1789  
 
 1790  0
                     match(input, Token.DOWN, null); 
 1791  0
                     _last = (CommonTree)input.LT(1);
 1792  0
                     pushFollow(FOLLOW_var_in_selectVariables326);
 1793  0
                     var44=var();
 1794  
 
 1795  0
                     state._fsp--;
 1796  
 
 1797  0
                     adaptor.addChild(root_1, var44.getTree());
 1798  
 
 1799  
 
 1800  0
                     match(input, Token.UP, null); 
 1801  0
                     adaptor.addChild(root_0, root_1);
 1802  0
                     _last = _save_last_1;
 1803  
                     }
 1804  
 
 1805  
 
 1806  
                     }
 1807  0
                     break;
 1808  
                 case 2 :
 1809  
                     // com\\googlecode\\sparkleg\\SparqlT.g:73:7: ^( AS expression var )
 1810  
                     {
 1811  0
                     root_0 = (CommonTree)adaptor.nil();
 1812  
 
 1813  
 
 1814  0
                     _last = (CommonTree)input.LT(1);
 1815  
                     {
 1816  0
                     CommonTree _save_last_1 = _last;
 1817  0
                     CommonTree _first_1 = null;
 1818  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 1819  0
                     _last = (CommonTree)input.LT(1);
 1820  0
                     AS45=(CommonTree)match(input,AS,FOLLOW_AS_in_selectVariables337); 
 1821  0
                     AS45_tree = (CommonTree)adaptor.dupNode(AS45);
 1822  
 
 1823  
 
 1824  0
                     root_1 = (CommonTree)adaptor.becomeRoot(AS45_tree, root_1);
 1825  
 
 1826  
 
 1827  0
                     match(input, Token.DOWN, null); 
 1828  0
                     _last = (CommonTree)input.LT(1);
 1829  0
                     pushFollow(FOLLOW_expression_in_selectVariables339);
 1830  0
                     expression46=expression();
 1831  
 
 1832  0
                     state._fsp--;
 1833  
 
 1834  0
                     adaptor.addChild(root_1, expression46.getTree());
 1835  
 
 1836  
 
 1837  0
                     _last = (CommonTree)input.LT(1);
 1838  0
                     pushFollow(FOLLOW_var_in_selectVariables341);
 1839  0
                     var47=var();
 1840  
 
 1841  0
                     state._fsp--;
 1842  
 
 1843  0
                     adaptor.addChild(root_1, var47.getTree());
 1844  
 
 1845  
 
 1846  0
                     match(input, Token.UP, null); 
 1847  0
                     adaptor.addChild(root_0, root_1);
 1848  0
                     _last = _save_last_1;
 1849  
                     }
 1850  
 
 1851  
 
 1852  
                     }
 1853  
                     break;
 1854  
 
 1855  
             }
 1856  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 1857  
 
 1858  
         }
 1859  0
         catch (RecognitionException re) {
 1860  0
             reportError(re);
 1861  0
             recover(input,re);
 1862  
         }
 1863  
 
 1864  0
         finally {
 1865  
                 // do for sure before leaving
 1866  0
         }
 1867  0
         return retval;
 1868  
     }
 1869  
     // $ANTLR end "selectVariables"
 1870  
 
 1871  
 
 1872  0
     public static class constructQuery_return extends TreeRuleReturnScope {
 1873  
         CommonTree tree;
 1874  0
         public Object getTree() { return tree; }
 1875  
     };
 1876  
 
 1877  
 
 1878  
     // $ANTLR start "constructQuery"
 1879  
     // com\\googlecode\\sparkleg\\SparqlT.g:76:1: constructQuery : ( ^( CONSTRUCT constructTemplate ( datasetClause )* ( whereClause )? solutionModifier ) | ^( CONSTRUCT ( datasetClause )* ( whereClause )? solutionModifier ) );
 1880  
     public final SparqlT.constructQuery_return constructQuery() throws RecognitionException {
 1881  0
         SparqlT.constructQuery_return retval = new SparqlT.constructQuery_return();
 1882  0
         retval.start = input.LT(1);
 1883  
 
 1884  
 
 1885  0
         CommonTree root_0 = null;
 1886  
 
 1887  0
         CommonTree _first_0 = null;
 1888  0
         CommonTree _last = null;
 1889  
 
 1890  0
         CommonTree CONSTRUCT48=null;
 1891  0
         CommonTree CONSTRUCT53=null;
 1892  0
         SparqlT.constructTemplate_return constructTemplate49 =null;
 1893  
 
 1894  0
         SparqlT.datasetClause_return datasetClause50 =null;
 1895  
 
 1896  0
         SparqlT.whereClause_return whereClause51 =null;
 1897  
 
 1898  0
         SparqlT.solutionModifier_return solutionModifier52 =null;
 1899  
 
 1900  0
         SparqlT.datasetClause_return datasetClause54 =null;
 1901  
 
 1902  0
         SparqlT.whereClause_return whereClause55 =null;
 1903  
 
 1904  0
         SparqlT.solutionModifier_return solutionModifier56 =null;
 1905  
 
 1906  
 
 1907  0
         CommonTree CONSTRUCT48_tree=null;
 1908  0
         CommonTree CONSTRUCT53_tree=null;
 1909  
 
 1910  
         try {
 1911  
             // com\\googlecode\\sparkleg\\SparqlT.g:77:5: ( ^( CONSTRUCT constructTemplate ( datasetClause )* ( whereClause )? solutionModifier ) | ^( CONSTRUCT ( datasetClause )* ( whereClause )? solutionModifier ) )
 1912  0
             int alt23=2;
 1913  0
             switch ( input.LA(1) ) {
 1914  
             case CONSTRUCT:
 1915  
                 {
 1916  0
                 switch ( input.LA(2) ) {
 1917  
                 case DOWN:
 1918  
                     {
 1919  0
                     switch ( input.LA(3) ) {
 1920  
                     case CONSTRUCT_TRIPLES:
 1921  
                         {
 1922  0
                         alt23=1;
 1923  
                         }
 1924  0
                         break;
 1925  
                     case UP:
 1926  
                     case FROM:
 1927  
                     case GROUP_BY:
 1928  
                     case HAVING:
 1929  
                     case LIMIT:
 1930  
                     case OFFSET:
 1931  
                     case ORDER_BY:
 1932  
                     case WHERE_CLAUSE:
 1933  
                         {
 1934  0
                         alt23=2;
 1935  
                         }
 1936  0
                         break;
 1937  
                     default:
 1938  0
                         NoViableAltException nvae =
 1939  
                             new NoViableAltException("", 23, 2, input);
 1940  
 
 1941  0
                         throw nvae;
 1942  
 
 1943  
                     }
 1944  
 
 1945  
                     }
 1946  0
                     break;
 1947  
                 default:
 1948  0
                     NoViableAltException nvae =
 1949  
                         new NoViableAltException("", 23, 1, input);
 1950  
 
 1951  0
                     throw nvae;
 1952  
 
 1953  
                 }
 1954  
 
 1955  
                 }
 1956  0
                 break;
 1957  
             default:
 1958  0
                 NoViableAltException nvae =
 1959  
                     new NoViableAltException("", 23, 0, input);
 1960  
 
 1961  0
                 throw nvae;
 1962  
 
 1963  
             }
 1964  
 
 1965  0
             switch (alt23) {
 1966  
                 case 1 :
 1967  
                     // com\\googlecode\\sparkleg\\SparqlT.g:77:7: ^( CONSTRUCT constructTemplate ( datasetClause )* ( whereClause )? solutionModifier )
 1968  
                     {
 1969  0
                     root_0 = (CommonTree)adaptor.nil();
 1970  
 
 1971  
 
 1972  0
                     _last = (CommonTree)input.LT(1);
 1973  
                     {
 1974  0
                     CommonTree _save_last_1 = _last;
 1975  0
                     CommonTree _first_1 = null;
 1976  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 1977  0
                     _last = (CommonTree)input.LT(1);
 1978  0
                     CONSTRUCT48=(CommonTree)match(input,CONSTRUCT,FOLLOW_CONSTRUCT_in_constructQuery362); 
 1979  0
                     CONSTRUCT48_tree = (CommonTree)adaptor.dupNode(CONSTRUCT48);
 1980  
 
 1981  
 
 1982  0
                     root_1 = (CommonTree)adaptor.becomeRoot(CONSTRUCT48_tree, root_1);
 1983  
 
 1984  
 
 1985  0
                     match(input, Token.DOWN, null); 
 1986  0
                     _last = (CommonTree)input.LT(1);
 1987  0
                     pushFollow(FOLLOW_constructTemplate_in_constructQuery364);
 1988  0
                     constructTemplate49=constructTemplate();
 1989  
 
 1990  0
                     state._fsp--;
 1991  
 
 1992  0
                     adaptor.addChild(root_1, constructTemplate49.getTree());
 1993  
 
 1994  
 
 1995  
                     // com\\googlecode\\sparkleg\\SparqlT.g:77:37: ( datasetClause )*
 1996  
                     loop19:
 1997  
                     do {
 1998  0
                         int alt19=2;
 1999  0
                         switch ( input.LA(1) ) {
 2000  
                         case FROM:
 2001  
                             {
 2002  0
                             alt19=1;
 2003  
                             }
 2004  
                             break;
 2005  
 
 2006  
                         }
 2007  
 
 2008  0
                         switch (alt19) {
 2009  
                             case 1 :
 2010  
                                 // com\\googlecode\\sparkleg\\SparqlT.g:77:37: datasetClause
 2011  
                                 {
 2012  0
                                 _last = (CommonTree)input.LT(1);
 2013  0
                                 pushFollow(FOLLOW_datasetClause_in_constructQuery366);
 2014  0
                                 datasetClause50=datasetClause();
 2015  
 
 2016  0
                                 state._fsp--;
 2017  
 
 2018  0
                                 adaptor.addChild(root_1, datasetClause50.getTree());
 2019  
 
 2020  
 
 2021  
                                 }
 2022  0
                                 break;
 2023  
 
 2024  
                             default :
 2025  0
                                 break loop19;
 2026  
                         }
 2027  0
                     } while (true);
 2028  
 
 2029  
 
 2030  
                     // com\\googlecode\\sparkleg\\SparqlT.g:77:52: ( whereClause )?
 2031  0
                     int alt20=2;
 2032  0
                     switch ( input.LA(1) ) {
 2033  
                         case WHERE_CLAUSE:
 2034  
                             {
 2035  0
                             alt20=1;
 2036  
                             }
 2037  
                             break;
 2038  
                     }
 2039  
 
 2040  0
                     switch (alt20) {
 2041  
                         case 1 :
 2042  
                             // com\\googlecode\\sparkleg\\SparqlT.g:77:52: whereClause
 2043  
                             {
 2044  0
                             _last = (CommonTree)input.LT(1);
 2045  0
                             pushFollow(FOLLOW_whereClause_in_constructQuery369);
 2046  0
                             whereClause51=whereClause();
 2047  
 
 2048  0
                             state._fsp--;
 2049  
 
 2050  0
                             adaptor.addChild(root_1, whereClause51.getTree());
 2051  
 
 2052  
 
 2053  
                             }
 2054  
                             break;
 2055  
 
 2056  
                     }
 2057  
 
 2058  
 
 2059  0
                     _last = (CommonTree)input.LT(1);
 2060  0
                     pushFollow(FOLLOW_solutionModifier_in_constructQuery372);
 2061  0
                     solutionModifier52=solutionModifier();
 2062  
 
 2063  0
                     state._fsp--;
 2064  
 
 2065  0
                     adaptor.addChild(root_1, solutionModifier52.getTree());
 2066  
 
 2067  
 
 2068  0
                     match(input, Token.UP, null); 
 2069  0
                     adaptor.addChild(root_0, root_1);
 2070  0
                     _last = _save_last_1;
 2071  
                     }
 2072  
 
 2073  
 
 2074  
                     }
 2075  0
                     break;
 2076  
                 case 2 :
 2077  
                     // com\\googlecode\\sparkleg\\SparqlT.g:78:7: ^( CONSTRUCT ( datasetClause )* ( whereClause )? solutionModifier )
 2078  
                     {
 2079  0
                     root_0 = (CommonTree)adaptor.nil();
 2080  
 
 2081  
 
 2082  0
                     _last = (CommonTree)input.LT(1);
 2083  
                     {
 2084  0
                     CommonTree _save_last_1 = _last;
 2085  0
                     CommonTree _first_1 = null;
 2086  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 2087  0
                     _last = (CommonTree)input.LT(1);
 2088  0
                     CONSTRUCT53=(CommonTree)match(input,CONSTRUCT,FOLLOW_CONSTRUCT_in_constructQuery382); 
 2089  0
                     CONSTRUCT53_tree = (CommonTree)adaptor.dupNode(CONSTRUCT53);
 2090  
 
 2091  
 
 2092  0
                     root_1 = (CommonTree)adaptor.becomeRoot(CONSTRUCT53_tree, root_1);
 2093  
 
 2094  
 
 2095  0
                     if ( input.LA(1)==Token.DOWN ) {
 2096  0
                         match(input, Token.DOWN, null); 
 2097  
                         // com\\googlecode\\sparkleg\\SparqlT.g:78:19: ( datasetClause )*
 2098  
                         loop21:
 2099  
                         do {
 2100  0
                             int alt21=2;
 2101  0
                             switch ( input.LA(1) ) {
 2102  
                             case FROM:
 2103  
                                 {
 2104  0
                                 alt21=1;
 2105  
                                 }
 2106  
                                 break;
 2107  
 
 2108  
                             }
 2109  
 
 2110  0
                             switch (alt21) {
 2111  
                                 case 1 :
 2112  
                                     // com\\googlecode\\sparkleg\\SparqlT.g:78:19: datasetClause
 2113  
                                     {
 2114  0
                                     _last = (CommonTree)input.LT(1);
 2115  0
                                     pushFollow(FOLLOW_datasetClause_in_constructQuery384);
 2116  0
                                     datasetClause54=datasetClause();
 2117  
 
 2118  0
                                     state._fsp--;
 2119  
 
 2120  0
                                     adaptor.addChild(root_1, datasetClause54.getTree());
 2121  
 
 2122  
 
 2123  
                                     }
 2124  0
                                     break;
 2125  
 
 2126  
                                 default :
 2127  0
                                     break loop21;
 2128  
                             }
 2129  0
                         } while (true);
 2130  
 
 2131  
 
 2132  
                         // com\\googlecode\\sparkleg\\SparqlT.g:78:34: ( whereClause )?
 2133  0
                         int alt22=2;
 2134  0
                         switch ( input.LA(1) ) {
 2135  
                             case WHERE_CLAUSE:
 2136  
                                 {
 2137  0
                                 alt22=1;
 2138  
                                 }
 2139  
                                 break;
 2140  
                         }
 2141  
 
 2142  0
                         switch (alt22) {
 2143  
                             case 1 :
 2144  
                                 // com\\googlecode\\sparkleg\\SparqlT.g:78:34: whereClause
 2145  
                                 {
 2146  0
                                 _last = (CommonTree)input.LT(1);
 2147  0
                                 pushFollow(FOLLOW_whereClause_in_constructQuery387);
 2148  0
                                 whereClause55=whereClause();
 2149  
 
 2150  0
                                 state._fsp--;
 2151  
 
 2152  0
                                 adaptor.addChild(root_1, whereClause55.getTree());
 2153  
 
 2154  
 
 2155  
                                 }
 2156  
                                 break;
 2157  
 
 2158  
                         }
 2159  
 
 2160  
 
 2161  0
                         _last = (CommonTree)input.LT(1);
 2162  0
                         pushFollow(FOLLOW_solutionModifier_in_constructQuery390);
 2163  0
                         solutionModifier56=solutionModifier();
 2164  
 
 2165  0
                         state._fsp--;
 2166  
 
 2167  0
                         adaptor.addChild(root_1, solutionModifier56.getTree());
 2168  
 
 2169  
 
 2170  0
                         match(input, Token.UP, null); 
 2171  
                     }
 2172  0
                     adaptor.addChild(root_0, root_1);
 2173  0
                     _last = _save_last_1;
 2174  
                     }
 2175  
 
 2176  
 
 2177  
                     }
 2178  
                     break;
 2179  
 
 2180  
             }
 2181  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 2182  
 
 2183  
         }
 2184  0
         catch (RecognitionException re) {
 2185  0
             reportError(re);
 2186  0
             recover(input,re);
 2187  
         }
 2188  
 
 2189  0
         finally {
 2190  
                 // do for sure before leaving
 2191  0
         }
 2192  0
         return retval;
 2193  
     }
 2194  
     // $ANTLR end "constructQuery"
 2195  
 
 2196  
 
 2197  0
     public static class describeQuery_return extends TreeRuleReturnScope {
 2198  
         CommonTree tree;
 2199  0
         public Object getTree() { return tree; }
 2200  
     };
 2201  
 
 2202  
 
 2203  
     // $ANTLR start "describeQuery"
 2204  
     // com\\googlecode\\sparkleg\\SparqlT.g:81:1: describeQuery : ^( DESCRIBE ( varOrIRIref )* ( ASTERISK )* ( datasetClause )* ( whereClause )? solutionModifier ) ;
 2205  
     public final SparqlT.describeQuery_return describeQuery() throws RecognitionException {
 2206  0
         SparqlT.describeQuery_return retval = new SparqlT.describeQuery_return();
 2207  0
         retval.start = input.LT(1);
 2208  
 
 2209  
 
 2210  0
         CommonTree root_0 = null;
 2211  
 
 2212  0
         CommonTree _first_0 = null;
 2213  0
         CommonTree _last = null;
 2214  
 
 2215  0
         CommonTree DESCRIBE57=null;
 2216  0
         CommonTree ASTERISK59=null;
 2217  0
         SparqlT.varOrIRIref_return varOrIRIref58 =null;
 2218  
 
 2219  0
         SparqlT.datasetClause_return datasetClause60 =null;
 2220  
 
 2221  0
         SparqlT.whereClause_return whereClause61 =null;
 2222  
 
 2223  0
         SparqlT.solutionModifier_return solutionModifier62 =null;
 2224  
 
 2225  
 
 2226  0
         CommonTree DESCRIBE57_tree=null;
 2227  0
         CommonTree ASTERISK59_tree=null;
 2228  
 
 2229  
         try {
 2230  
             // com\\googlecode\\sparkleg\\SparqlT.g:82:5: ( ^( DESCRIBE ( varOrIRIref )* ( ASTERISK )* ( datasetClause )* ( whereClause )? solutionModifier ) )
 2231  
             // com\\googlecode\\sparkleg\\SparqlT.g:82:7: ^( DESCRIBE ( varOrIRIref )* ( ASTERISK )* ( datasetClause )* ( whereClause )? solutionModifier )
 2232  
             {
 2233  0
             root_0 = (CommonTree)adaptor.nil();
 2234  
 
 2235  
 
 2236  0
             _last = (CommonTree)input.LT(1);
 2237  
             {
 2238  0
             CommonTree _save_last_1 = _last;
 2239  0
             CommonTree _first_1 = null;
 2240  0
             CommonTree root_1 = (CommonTree)adaptor.nil();
 2241  0
             _last = (CommonTree)input.LT(1);
 2242  0
             DESCRIBE57=(CommonTree)match(input,DESCRIBE,FOLLOW_DESCRIBE_in_describeQuery409); 
 2243  0
             DESCRIBE57_tree = (CommonTree)adaptor.dupNode(DESCRIBE57);
 2244  
 
 2245  
 
 2246  0
             root_1 = (CommonTree)adaptor.becomeRoot(DESCRIBE57_tree, root_1);
 2247  
 
 2248  
 
 2249  0
             if ( input.LA(1)==Token.DOWN ) {
 2250  0
                 match(input, Token.DOWN, null); 
 2251  
                 // com\\googlecode\\sparkleg\\SparqlT.g:82:18: ( varOrIRIref )*
 2252  
                 loop24:
 2253  
                 do {
 2254  0
                     int alt24=2;
 2255  0
                     switch ( input.LA(1) ) {
 2256  
                     case IRI_REF:
 2257  
                     case PNAME_LN:
 2258  
                     case PNAME_NS:
 2259  
                     case VAR1:
 2260  
                     case VAR2:
 2261  
                         {
 2262  0
                         alt24=1;
 2263  
                         }
 2264  
                         break;
 2265  
 
 2266  
                     }
 2267  
 
 2268  0
                     switch (alt24) {
 2269  
                         case 1 :
 2270  
                             // com\\googlecode\\sparkleg\\SparqlT.g:82:18: varOrIRIref
 2271  
                             {
 2272  0
                             _last = (CommonTree)input.LT(1);
 2273  0
                             pushFollow(FOLLOW_varOrIRIref_in_describeQuery411);
 2274  0
                             varOrIRIref58=varOrIRIref();
 2275  
 
 2276  0
                             state._fsp--;
 2277  
 
 2278  0
                             adaptor.addChild(root_1, varOrIRIref58.getTree());
 2279  
 
 2280  
 
 2281  
                             }
 2282  0
                             break;
 2283  
 
 2284  
                         default :
 2285  0
                             break loop24;
 2286  
                     }
 2287  0
                 } while (true);
 2288  
 
 2289  
 
 2290  
                 // com\\googlecode\\sparkleg\\SparqlT.g:82:31: ( ASTERISK )*
 2291  
                 loop25:
 2292  
                 do {
 2293  0
                     int alt25=2;
 2294  0
                     switch ( input.LA(1) ) {
 2295  
                     case ASTERISK:
 2296  
                         {
 2297  0
                         alt25=1;
 2298  
                         }
 2299  
                         break;
 2300  
 
 2301  
                     }
 2302  
 
 2303  0
                     switch (alt25) {
 2304  
                         case 1 :
 2305  
                             // com\\googlecode\\sparkleg\\SparqlT.g:82:31: ASTERISK
 2306  
                             {
 2307  0
                             _last = (CommonTree)input.LT(1);
 2308  0
                             ASTERISK59=(CommonTree)match(input,ASTERISK,FOLLOW_ASTERISK_in_describeQuery414); 
 2309  0
                             ASTERISK59_tree = (CommonTree)adaptor.dupNode(ASTERISK59);
 2310  
 
 2311  
 
 2312  0
                             adaptor.addChild(root_1, ASTERISK59_tree);
 2313  
 
 2314  
 
 2315  
                             }
 2316  0
                             break;
 2317  
 
 2318  
                         default :
 2319  0
                             break loop25;
 2320  
                     }
 2321  0
                 } while (true);
 2322  
 
 2323  
 
 2324  
                 // com\\googlecode\\sparkleg\\SparqlT.g:82:41: ( datasetClause )*
 2325  
                 loop26:
 2326  
                 do {
 2327  0
                     int alt26=2;
 2328  0
                     switch ( input.LA(1) ) {
 2329  
                     case FROM:
 2330  
                         {
 2331  0
                         alt26=1;
 2332  
                         }
 2333  
                         break;
 2334  
 
 2335  
                     }
 2336  
 
 2337  0
                     switch (alt26) {
 2338  
                         case 1 :
 2339  
                             // com\\googlecode\\sparkleg\\SparqlT.g:82:41: datasetClause
 2340  
                             {
 2341  0
                             _last = (CommonTree)input.LT(1);
 2342  0
                             pushFollow(FOLLOW_datasetClause_in_describeQuery417);
 2343  0
                             datasetClause60=datasetClause();
 2344  
 
 2345  0
                             state._fsp--;
 2346  
 
 2347  0
                             adaptor.addChild(root_1, datasetClause60.getTree());
 2348  
 
 2349  
 
 2350  
                             }
 2351  0
                             break;
 2352  
 
 2353  
                         default :
 2354  0
                             break loop26;
 2355  
                     }
 2356  0
                 } while (true);
 2357  
 
 2358  
 
 2359  
                 // com\\googlecode\\sparkleg\\SparqlT.g:82:56: ( whereClause )?
 2360  0
                 int alt27=2;
 2361  0
                 switch ( input.LA(1) ) {
 2362  
                     case WHERE_CLAUSE:
 2363  
                         {
 2364  0
                         alt27=1;
 2365  
                         }
 2366  
                         break;
 2367  
                 }
 2368  
 
 2369  0
                 switch (alt27) {
 2370  
                     case 1 :
 2371  
                         // com\\googlecode\\sparkleg\\SparqlT.g:82:56: whereClause
 2372  
                         {
 2373  0
                         _last = (CommonTree)input.LT(1);
 2374  0
                         pushFollow(FOLLOW_whereClause_in_describeQuery420);
 2375  0
                         whereClause61=whereClause();
 2376  
 
 2377  0
                         state._fsp--;
 2378  
 
 2379  0
                         adaptor.addChild(root_1, whereClause61.getTree());
 2380  
 
 2381  
 
 2382  
                         }
 2383  
                         break;
 2384  
 
 2385  
                 }
 2386  
 
 2387  
 
 2388  0
                 _last = (CommonTree)input.LT(1);
 2389  0
                 pushFollow(FOLLOW_solutionModifier_in_describeQuery423);
 2390  0
                 solutionModifier62=solutionModifier();
 2391  
 
 2392  0
                 state._fsp--;
 2393  
 
 2394  0
                 adaptor.addChild(root_1, solutionModifier62.getTree());
 2395  
 
 2396  
 
 2397  0
                 match(input, Token.UP, null); 
 2398  
             }
 2399  0
             adaptor.addChild(root_0, root_1);
 2400  0
             _last = _save_last_1;
 2401  
             }
 2402  
 
 2403  
 
 2404  
             }
 2405  
 
 2406  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 2407  
 
 2408  
         }
 2409  0
         catch (RecognitionException re) {
 2410  0
             reportError(re);
 2411  0
             recover(input,re);
 2412  
         }
 2413  
 
 2414  0
         finally {
 2415  
                 // do for sure before leaving
 2416  0
         }
 2417  0
         return retval;
 2418  
     }
 2419  
     // $ANTLR end "describeQuery"
 2420  
 
 2421  
 
 2422  0
     public static class askQuery_return extends TreeRuleReturnScope {
 2423  
         CommonTree tree;
 2424  0
         public Object getTree() { return tree; }
 2425  
     };
 2426  
 
 2427  
 
 2428  
     // $ANTLR start "askQuery"
 2429  
     // com\\googlecode\\sparkleg\\SparqlT.g:85:1: askQuery : ^( ASK ( datasetClause )* whereClause ) ;
 2430  
     public final SparqlT.askQuery_return askQuery() throws RecognitionException {
 2431  0
         SparqlT.askQuery_return retval = new SparqlT.askQuery_return();
 2432  0
         retval.start = input.LT(1);
 2433  
 
 2434  
 
 2435  0
         CommonTree root_0 = null;
 2436  
 
 2437  0
         CommonTree _first_0 = null;
 2438  0
         CommonTree _last = null;
 2439  
 
 2440  0
         CommonTree ASK63=null;
 2441  0
         SparqlT.datasetClause_return datasetClause64 =null;
 2442  
 
 2443  0
         SparqlT.whereClause_return whereClause65 =null;
 2444  
 
 2445  
 
 2446  0
         CommonTree ASK63_tree=null;
 2447  
 
 2448  
         try {
 2449  
             // com\\googlecode\\sparkleg\\SparqlT.g:86:5: ( ^( ASK ( datasetClause )* whereClause ) )
 2450  
             // com\\googlecode\\sparkleg\\SparqlT.g:86:7: ^( ASK ( datasetClause )* whereClause )
 2451  
             {
 2452  0
             root_0 = (CommonTree)adaptor.nil();
 2453  
 
 2454  
 
 2455  0
             _last = (CommonTree)input.LT(1);
 2456  
             {
 2457  0
             CommonTree _save_last_1 = _last;
 2458  0
             CommonTree _first_1 = null;
 2459  0
             CommonTree root_1 = (CommonTree)adaptor.nil();
 2460  0
             _last = (CommonTree)input.LT(1);
 2461  0
             ASK63=(CommonTree)match(input,ASK,FOLLOW_ASK_in_askQuery442); 
 2462  0
             ASK63_tree = (CommonTree)adaptor.dupNode(ASK63);
 2463  
 
 2464  
 
 2465  0
             root_1 = (CommonTree)adaptor.becomeRoot(ASK63_tree, root_1);
 2466  
 
 2467  
 
 2468  0
             match(input, Token.DOWN, null); 
 2469  
             // com\\googlecode\\sparkleg\\SparqlT.g:86:13: ( datasetClause )*
 2470  
             loop28:
 2471  
             do {
 2472  0
                 int alt28=2;
 2473  0
                 switch ( input.LA(1) ) {
 2474  
                 case FROM:
 2475  
                     {
 2476  0
                     alt28=1;
 2477  
                     }
 2478  
                     break;
 2479  
 
 2480  
                 }
 2481  
 
 2482  0
                 switch (alt28) {
 2483  
                     case 1 :
 2484  
                         // com\\googlecode\\sparkleg\\SparqlT.g:86:13: datasetClause
 2485  
                         {
 2486  0
                         _last = (CommonTree)input.LT(1);
 2487  0
                         pushFollow(FOLLOW_datasetClause_in_askQuery444);
 2488  0
                         datasetClause64=datasetClause();
 2489  
 
 2490  0
                         state._fsp--;
 2491  
 
 2492  0
                         adaptor.addChild(root_1, datasetClause64.getTree());
 2493  
 
 2494  
 
 2495  
                         }
 2496  0
                         break;
 2497  
 
 2498  
                     default :
 2499  0
                         break loop28;
 2500  
                 }
 2501  0
             } while (true);
 2502  
 
 2503  
 
 2504  0
             _last = (CommonTree)input.LT(1);
 2505  0
             pushFollow(FOLLOW_whereClause_in_askQuery447);
 2506  0
             whereClause65=whereClause();
 2507  
 
 2508  0
             state._fsp--;
 2509  
 
 2510  0
             adaptor.addChild(root_1, whereClause65.getTree());
 2511  
 
 2512  
 
 2513  0
             match(input, Token.UP, null); 
 2514  0
             adaptor.addChild(root_0, root_1);
 2515  0
             _last = _save_last_1;
 2516  
             }
 2517  
 
 2518  
 
 2519  
             }
 2520  
 
 2521  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 2522  
 
 2523  
         }
 2524  0
         catch (RecognitionException re) {
 2525  0
             reportError(re);
 2526  0
             recover(input,re);
 2527  
         }
 2528  
 
 2529  0
         finally {
 2530  
                 // do for sure before leaving
 2531  0
         }
 2532  0
         return retval;
 2533  
     }
 2534  
     // $ANTLR end "askQuery"
 2535  
 
 2536  
 
 2537  0
     public static class datasetClause_return extends TreeRuleReturnScope {
 2538  
         CommonTree tree;
 2539  0
         public Object getTree() { return tree; }
 2540  
     };
 2541  
 
 2542  
 
 2543  
     // $ANTLR start "datasetClause"
 2544  
     // com\\googlecode\\sparkleg\\SparqlT.g:89:1: datasetClause : ^( FROM ( NAMED )? iriRef ) ;
 2545  
     public final SparqlT.datasetClause_return datasetClause() throws RecognitionException {
 2546  0
         SparqlT.datasetClause_return retval = new SparqlT.datasetClause_return();
 2547  0
         retval.start = input.LT(1);
 2548  
 
 2549  
 
 2550  0
         CommonTree root_0 = null;
 2551  
 
 2552  0
         CommonTree _first_0 = null;
 2553  0
         CommonTree _last = null;
 2554  
 
 2555  0
         CommonTree FROM66=null;
 2556  0
         CommonTree NAMED67=null;
 2557  0
         SparqlT.iriRef_return iriRef68 =null;
 2558  
 
 2559  
 
 2560  0
         CommonTree FROM66_tree=null;
 2561  0
         CommonTree NAMED67_tree=null;
 2562  
 
 2563  
         try {
 2564  
             // com\\googlecode\\sparkleg\\SparqlT.g:90:5: ( ^( FROM ( NAMED )? iriRef ) )
 2565  
             // com\\googlecode\\sparkleg\\SparqlT.g:90:7: ^( FROM ( NAMED )? iriRef )
 2566  
             {
 2567  0
             root_0 = (CommonTree)adaptor.nil();
 2568  
 
 2569  
 
 2570  0
             _last = (CommonTree)input.LT(1);
 2571  
             {
 2572  0
             CommonTree _save_last_1 = _last;
 2573  0
             CommonTree _first_1 = null;
 2574  0
             CommonTree root_1 = (CommonTree)adaptor.nil();
 2575  0
             _last = (CommonTree)input.LT(1);
 2576  0
             FROM66=(CommonTree)match(input,FROM,FOLLOW_FROM_in_datasetClause466); 
 2577  0
             FROM66_tree = (CommonTree)adaptor.dupNode(FROM66);
 2578  
 
 2579  
 
 2580  0
             root_1 = (CommonTree)adaptor.becomeRoot(FROM66_tree, root_1);
 2581  
 
 2582  
 
 2583  0
             match(input, Token.DOWN, null); 
 2584  
             // com\\googlecode\\sparkleg\\SparqlT.g:90:14: ( NAMED )?
 2585  0
             int alt29=2;
 2586  0
             switch ( input.LA(1) ) {
 2587  
                 case NAMED:
 2588  
                     {
 2589  0
                     alt29=1;
 2590  
                     }
 2591  
                     break;
 2592  
             }
 2593  
 
 2594  0
             switch (alt29) {
 2595  
                 case 1 :
 2596  
                     // com\\googlecode\\sparkleg\\SparqlT.g:90:14: NAMED
 2597  
                     {
 2598  0
                     _last = (CommonTree)input.LT(1);
 2599  0
                     NAMED67=(CommonTree)match(input,NAMED,FOLLOW_NAMED_in_datasetClause468); 
 2600  0
                     NAMED67_tree = (CommonTree)adaptor.dupNode(NAMED67);
 2601  
 
 2602  
 
 2603  0
                     adaptor.addChild(root_1, NAMED67_tree);
 2604  
 
 2605  
 
 2606  
                     }
 2607  
                     break;
 2608  
 
 2609  
             }
 2610  
 
 2611  
 
 2612  0
             _last = (CommonTree)input.LT(1);
 2613  0
             pushFollow(FOLLOW_iriRef_in_datasetClause471);
 2614  0
             iriRef68=iriRef();
 2615  
 
 2616  0
             state._fsp--;
 2617  
 
 2618  0
             adaptor.addChild(root_1, iriRef68.getTree());
 2619  
 
 2620  
 
 2621  0
             match(input, Token.UP, null); 
 2622  0
             adaptor.addChild(root_0, root_1);
 2623  0
             _last = _save_last_1;
 2624  
             }
 2625  
 
 2626  
 
 2627  
             }
 2628  
 
 2629  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 2630  
 
 2631  
         }
 2632  0
         catch (RecognitionException re) {
 2633  0
             reportError(re);
 2634  0
             recover(input,re);
 2635  
         }
 2636  
 
 2637  0
         finally {
 2638  
                 // do for sure before leaving
 2639  0
         }
 2640  0
         return retval;
 2641  
     }
 2642  
     // $ANTLR end "datasetClause"
 2643  
 
 2644  
 
 2645  0
     public static class whereClause_return extends TreeRuleReturnScope {
 2646  
         CommonTree tree;
 2647  0
         public Object getTree() { return tree; }
 2648  
     };
 2649  
 
 2650  
 
 2651  
     // $ANTLR start "whereClause"
 2652  
     // com\\googlecode\\sparkleg\\SparqlT.g:93:1: whereClause : ^( WHERE_CLAUSE ( groupGraphPattern )? ) ;
 2653  
     public final SparqlT.whereClause_return whereClause() throws RecognitionException {
 2654  0
         SparqlT.whereClause_return retval = new SparqlT.whereClause_return();
 2655  0
         retval.start = input.LT(1);
 2656  
 
 2657  
 
 2658  0
         CommonTree root_0 = null;
 2659  
 
 2660  0
         CommonTree _first_0 = null;
 2661  0
         CommonTree _last = null;
 2662  
 
 2663  0
         CommonTree WHERE_CLAUSE69=null;
 2664  0
         SparqlT.groupGraphPattern_return groupGraphPattern70 =null;
 2665  
 
 2666  
 
 2667  0
         CommonTree WHERE_CLAUSE69_tree=null;
 2668  
 
 2669  
         try {
 2670  
             // com\\googlecode\\sparkleg\\SparqlT.g:94:5: ( ^( WHERE_CLAUSE ( groupGraphPattern )? ) )
 2671  
             // com\\googlecode\\sparkleg\\SparqlT.g:94:7: ^( WHERE_CLAUSE ( groupGraphPattern )? )
 2672  
             {
 2673  0
             root_0 = (CommonTree)adaptor.nil();
 2674  
 
 2675  
 
 2676  0
             _last = (CommonTree)input.LT(1);
 2677  
             {
 2678  0
             CommonTree _save_last_1 = _last;
 2679  0
             CommonTree _first_1 = null;
 2680  0
             CommonTree root_1 = (CommonTree)adaptor.nil();
 2681  0
             _last = (CommonTree)input.LT(1);
 2682  0
             WHERE_CLAUSE69=(CommonTree)match(input,WHERE_CLAUSE,FOLLOW_WHERE_CLAUSE_in_whereClause490); 
 2683  0
             WHERE_CLAUSE69_tree = (CommonTree)adaptor.dupNode(WHERE_CLAUSE69);
 2684  
 
 2685  
 
 2686  0
             root_1 = (CommonTree)adaptor.becomeRoot(WHERE_CLAUSE69_tree, root_1);
 2687  
 
 2688  
 
 2689  0
             if ( input.LA(1)==Token.DOWN ) {
 2690  0
                 match(input, Token.DOWN, null); 
 2691  
                 // com\\googlecode\\sparkleg\\SparqlT.g:94:22: ( groupGraphPattern )?
 2692  0
                 int alt30=2;
 2693  0
                 switch ( input.LA(1) ) {
 2694  
                     case GROUP_GRAPH_PATTERN:
 2695  
                         {
 2696  0
                         alt30=1;
 2697  
                         }
 2698  
                         break;
 2699  
                 }
 2700  
 
 2701  0
                 switch (alt30) {
 2702  
                     case 1 :
 2703  
                         // com\\googlecode\\sparkleg\\SparqlT.g:94:22: groupGraphPattern
 2704  
                         {
 2705  0
                         _last = (CommonTree)input.LT(1);
 2706  0
                         pushFollow(FOLLOW_groupGraphPattern_in_whereClause492);
 2707  0
                         groupGraphPattern70=groupGraphPattern();
 2708  
 
 2709  0
                         state._fsp--;
 2710  
 
 2711  0
                         adaptor.addChild(root_1, groupGraphPattern70.getTree());
 2712  
 
 2713  
 
 2714  
                         }
 2715  
                         break;
 2716  
 
 2717  
                 }
 2718  
 
 2719  
 
 2720  0
                 match(input, Token.UP, null); 
 2721  
             }
 2722  0
             adaptor.addChild(root_0, root_1);
 2723  0
             _last = _save_last_1;
 2724  
             }
 2725  
 
 2726  
 
 2727  
             }
 2728  
 
 2729  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 2730  
 
 2731  
         }
 2732  0
         catch (RecognitionException re) {
 2733  0
             reportError(re);
 2734  0
             recover(input,re);
 2735  
         }
 2736  
 
 2737  0
         finally {
 2738  
                 // do for sure before leaving
 2739  0
         }
 2740  0
         return retval;
 2741  
     }
 2742  
     // $ANTLR end "whereClause"
 2743  
 
 2744  
 
 2745  0
     public static class solutionModifier_return extends TreeRuleReturnScope {
 2746  
         CommonTree tree;
 2747  0
         public Object getTree() { return tree; }
 2748  
     };
 2749  
 
 2750  
 
 2751  
     // $ANTLR start "solutionModifier"
 2752  
     // com\\googlecode\\sparkleg\\SparqlT.g:97:1: solutionModifier : ( groupClause )? ( havingClause )? ( orderClause )? ( limitOffsetClauses )? ;
 2753  
     public final SparqlT.solutionModifier_return solutionModifier() throws RecognitionException {
 2754  0
         SparqlT.solutionModifier_return retval = new SparqlT.solutionModifier_return();
 2755  0
         retval.start = input.LT(1);
 2756  
 
 2757  
 
 2758  0
         CommonTree root_0 = null;
 2759  
 
 2760  0
         CommonTree _first_0 = null;
 2761  0
         CommonTree _last = null;
 2762  
 
 2763  0
         SparqlT.groupClause_return groupClause71 =null;
 2764  
 
 2765  0
         SparqlT.havingClause_return havingClause72 =null;
 2766  
 
 2767  0
         SparqlT.orderClause_return orderClause73 =null;
 2768  
 
 2769  0
         SparqlT.limitOffsetClauses_return limitOffsetClauses74 =null;
 2770  
 
 2771  
 
 2772  
 
 2773  
         try {
 2774  
             // com\\googlecode\\sparkleg\\SparqlT.g:98:5: ( ( groupClause )? ( havingClause )? ( orderClause )? ( limitOffsetClauses )? )
 2775  
             // com\\googlecode\\sparkleg\\SparqlT.g:98:7: ( groupClause )? ( havingClause )? ( orderClause )? ( limitOffsetClauses )?
 2776  
             {
 2777  0
             root_0 = (CommonTree)adaptor.nil();
 2778  
 
 2779  
 
 2780  
             // com\\googlecode\\sparkleg\\SparqlT.g:98:7: ( groupClause )?
 2781  0
             int alt31=2;
 2782  0
             switch ( input.LA(1) ) {
 2783  
                 case GROUP_BY:
 2784  
                     {
 2785  0
                     alt31=1;
 2786  
                     }
 2787  
                     break;
 2788  
             }
 2789  
 
 2790  0
             switch (alt31) {
 2791  
                 case 1 :
 2792  
                     // com\\googlecode\\sparkleg\\SparqlT.g:98:7: groupClause
 2793  
                     {
 2794  0
                     _last = (CommonTree)input.LT(1);
 2795  0
                     pushFollow(FOLLOW_groupClause_in_solutionModifier515);
 2796  0
                     groupClause71=groupClause();
 2797  
 
 2798  0
                     state._fsp--;
 2799  
 
 2800  0
                     adaptor.addChild(root_0, groupClause71.getTree());
 2801  
 
 2802  
 
 2803  
                     }
 2804  
                     break;
 2805  
 
 2806  
             }
 2807  
 
 2808  
 
 2809  
             // com\\googlecode\\sparkleg\\SparqlT.g:98:20: ( havingClause )?
 2810  0
             int alt32=2;
 2811  0
             switch ( input.LA(1) ) {
 2812  
                 case HAVING:
 2813  
                     {
 2814  0
                     alt32=1;
 2815  
                     }
 2816  
                     break;
 2817  
             }
 2818  
 
 2819  0
             switch (alt32) {
 2820  
                 case 1 :
 2821  
                     // com\\googlecode\\sparkleg\\SparqlT.g:98:20: havingClause
 2822  
                     {
 2823  0
                     _last = (CommonTree)input.LT(1);
 2824  0
                     pushFollow(FOLLOW_havingClause_in_solutionModifier518);
 2825  0
                     havingClause72=havingClause();
 2826  
 
 2827  0
                     state._fsp--;
 2828  
 
 2829  0
                     adaptor.addChild(root_0, havingClause72.getTree());
 2830  
 
 2831  
 
 2832  
                     }
 2833  
                     break;
 2834  
 
 2835  
             }
 2836  
 
 2837  
 
 2838  
             // com\\googlecode\\sparkleg\\SparqlT.g:98:34: ( orderClause )?
 2839  0
             int alt33=2;
 2840  0
             switch ( input.LA(1) ) {
 2841  
                 case ORDER_BY:
 2842  
                     {
 2843  0
                     alt33=1;
 2844  
                     }
 2845  
                     break;
 2846  
             }
 2847  
 
 2848  0
             switch (alt33) {
 2849  
                 case 1 :
 2850  
                     // com\\googlecode\\sparkleg\\SparqlT.g:98:34: orderClause
 2851  
                     {
 2852  0
                     _last = (CommonTree)input.LT(1);
 2853  0
                     pushFollow(FOLLOW_orderClause_in_solutionModifier521);
 2854  0
                     orderClause73=orderClause();
 2855  
 
 2856  0
                     state._fsp--;
 2857  
 
 2858  0
                     adaptor.addChild(root_0, orderClause73.getTree());
 2859  
 
 2860  
 
 2861  
                     }
 2862  
                     break;
 2863  
 
 2864  
             }
 2865  
 
 2866  
 
 2867  
             // com\\googlecode\\sparkleg\\SparqlT.g:98:47: ( limitOffsetClauses )?
 2868  0
             int alt34=2;
 2869  0
             switch ( input.LA(1) ) {
 2870  
                 case LIMIT:
 2871  
                 case OFFSET:
 2872  
                     {
 2873  0
                     alt34=1;
 2874  
                     }
 2875  
                     break;
 2876  
             }
 2877  
 
 2878  0
             switch (alt34) {
 2879  
                 case 1 :
 2880  
                     // com\\googlecode\\sparkleg\\SparqlT.g:98:47: limitOffsetClauses
 2881  
                     {
 2882  0
                     _last = (CommonTree)input.LT(1);
 2883  0
                     pushFollow(FOLLOW_limitOffsetClauses_in_solutionModifier524);
 2884  0
                     limitOffsetClauses74=limitOffsetClauses();
 2885  
 
 2886  0
                     state._fsp--;
 2887  
 
 2888  0
                     adaptor.addChild(root_0, limitOffsetClauses74.getTree());
 2889  
 
 2890  
 
 2891  
                     }
 2892  
                     break;
 2893  
 
 2894  
             }
 2895  
 
 2896  
 
 2897  
             }
 2898  
 
 2899  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 2900  
 
 2901  
         }
 2902  0
         catch (RecognitionException re) {
 2903  0
             reportError(re);
 2904  0
             recover(input,re);
 2905  
         }
 2906  
 
 2907  0
         finally {
 2908  
                 // do for sure before leaving
 2909  0
         }
 2910  0
         return retval;
 2911  
     }
 2912  
     // $ANTLR end "solutionModifier"
 2913  
 
 2914  
 
 2915  0
     public static class groupClause_return extends TreeRuleReturnScope {
 2916  
         CommonTree tree;
 2917  0
         public Object getTree() { return tree; }
 2918  
     };
 2919  
 
 2920  
 
 2921  
     // $ANTLR start "groupClause"
 2922  
     // com\\googlecode\\sparkleg\\SparqlT.g:101:1: groupClause : ^( GROUP_BY ( groupCondition )+ ) ;
 2923  
     public final SparqlT.groupClause_return groupClause() throws RecognitionException {
 2924  0
         SparqlT.groupClause_return retval = new SparqlT.groupClause_return();
 2925  0
         retval.start = input.LT(1);
 2926  
 
 2927  
 
 2928  0
         CommonTree root_0 = null;
 2929  
 
 2930  0
         CommonTree _first_0 = null;
 2931  0
         CommonTree _last = null;
 2932  
 
 2933  0
         CommonTree GROUP_BY75=null;
 2934  0
         SparqlT.groupCondition_return groupCondition76 =null;
 2935  
 
 2936  
 
 2937  0
         CommonTree GROUP_BY75_tree=null;
 2938  
 
 2939  
         try {
 2940  
             // com\\googlecode\\sparkleg\\SparqlT.g:102:5: ( ^( GROUP_BY ( groupCondition )+ ) )
 2941  
             // com\\googlecode\\sparkleg\\SparqlT.g:102:7: ^( GROUP_BY ( groupCondition )+ )
 2942  
             {
 2943  0
             root_0 = (CommonTree)adaptor.nil();
 2944  
 
 2945  
 
 2946  0
             _last = (CommonTree)input.LT(1);
 2947  
             {
 2948  0
             CommonTree _save_last_1 = _last;
 2949  0
             CommonTree _first_1 = null;
 2950  0
             CommonTree root_1 = (CommonTree)adaptor.nil();
 2951  0
             _last = (CommonTree)input.LT(1);
 2952  0
             GROUP_BY75=(CommonTree)match(input,GROUP_BY,FOLLOW_GROUP_BY_in_groupClause543); 
 2953  0
             GROUP_BY75_tree = (CommonTree)adaptor.dupNode(GROUP_BY75);
 2954  
 
 2955  
 
 2956  0
             root_1 = (CommonTree)adaptor.becomeRoot(GROUP_BY75_tree, root_1);
 2957  
 
 2958  
 
 2959  0
             match(input, Token.DOWN, null); 
 2960  
             // com\\googlecode\\sparkleg\\SparqlT.g:102:18: ( groupCondition )+
 2961  0
             int cnt35=0;
 2962  
             loop35:
 2963  
             do {
 2964  0
                 int alt35=2;
 2965  0
                 switch ( input.LA(1) ) {
 2966  
                 case GROUP_CONDITION:
 2967  
                     {
 2968  0
                     alt35=1;
 2969  
                     }
 2970  
                     break;
 2971  
 
 2972  
                 }
 2973  
 
 2974  0
                 switch (alt35) {
 2975  
                     case 1 :
 2976  
                         // com\\googlecode\\sparkleg\\SparqlT.g:102:18: groupCondition
 2977  
                         {
 2978  0
                         _last = (CommonTree)input.LT(1);
 2979  0
                         pushFollow(FOLLOW_groupCondition_in_groupClause545);
 2980  0
                         groupCondition76=groupCondition();
 2981  
 
 2982  0
                         state._fsp--;
 2983  
 
 2984  0
                         adaptor.addChild(root_1, groupCondition76.getTree());
 2985  
 
 2986  
 
 2987  
                         }
 2988  0
                         break;
 2989  
 
 2990  
                     default :
 2991  0
                         if ( cnt35 >= 1 ) break loop35;
 2992  0
                         EarlyExitException eee =
 2993  
                             new EarlyExitException(35, input);
 2994  0
                         throw eee;
 2995  
                 }
 2996  0
                 cnt35++;
 2997  0
             } while (true);
 2998  
 
 2999  
 
 3000  0
             match(input, Token.UP, null); 
 3001  0
             adaptor.addChild(root_0, root_1);
 3002  0
             _last = _save_last_1;
 3003  
             }
 3004  
 
 3005  
 
 3006  
             }
 3007  
 
 3008  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 3009  
 
 3010  
         }
 3011  0
         catch (RecognitionException re) {
 3012  0
             reportError(re);
 3013  0
             recover(input,re);
 3014  
         }
 3015  
 
 3016  0
         finally {
 3017  
                 // do for sure before leaving
 3018  0
         }
 3019  0
         return retval;
 3020  
     }
 3021  
     // $ANTLR end "groupClause"
 3022  
 
 3023  
 
 3024  0
     public static class groupCondition_return extends TreeRuleReturnScope {
 3025  
         CommonTree tree;
 3026  0
         public Object getTree() { return tree; }
 3027  
     };
 3028  
 
 3029  
 
 3030  
     // $ANTLR start "groupCondition"
 3031  
     // com\\googlecode\\sparkleg\\SparqlT.g:105:1: groupCondition : ( ^( GROUP_CONDITION builtInCall ) | ^( GROUP_CONDITION functionCall ) | ^( GROUP_CONDITION expression ^( AS ( var )? ) ) | ^( GROUP_CONDITION var ) );
 3032  
     public final SparqlT.groupCondition_return groupCondition() throws RecognitionException {
 3033  0
         SparqlT.groupCondition_return retval = new SparqlT.groupCondition_return();
 3034  0
         retval.start = input.LT(1);
 3035  
 
 3036  
 
 3037  0
         CommonTree root_0 = null;
 3038  
 
 3039  0
         CommonTree _first_0 = null;
 3040  0
         CommonTree _last = null;
 3041  
 
 3042  0
         CommonTree GROUP_CONDITION77=null;
 3043  0
         CommonTree GROUP_CONDITION79=null;
 3044  0
         CommonTree GROUP_CONDITION81=null;
 3045  0
         CommonTree AS83=null;
 3046  0
         CommonTree GROUP_CONDITION85=null;
 3047  0
         SparqlT.builtInCall_return builtInCall78 =null;
 3048  
 
 3049  0
         SparqlT.functionCall_return functionCall80 =null;
 3050  
 
 3051  0
         SparqlT.expression_return expression82 =null;
 3052  
 
 3053  0
         SparqlT.var_return var84 =null;
 3054  
 
 3055  0
         SparqlT.var_return var86 =null;
 3056  
 
 3057  
 
 3058  0
         CommonTree GROUP_CONDITION77_tree=null;
 3059  0
         CommonTree GROUP_CONDITION79_tree=null;
 3060  0
         CommonTree GROUP_CONDITION81_tree=null;
 3061  0
         CommonTree AS83_tree=null;
 3062  0
         CommonTree GROUP_CONDITION85_tree=null;
 3063  
 
 3064  
         try {
 3065  
             // com\\googlecode\\sparkleg\\SparqlT.g:106:5: ( ^( GROUP_CONDITION builtInCall ) | ^( GROUP_CONDITION functionCall ) | ^( GROUP_CONDITION expression ^( AS ( var )? ) ) | ^( GROUP_CONDITION var ) )
 3066  0
             int alt37=4;
 3067  0
             switch ( input.LA(1) ) {
 3068  
             case GROUP_CONDITION:
 3069  
                 {
 3070  0
                 switch ( input.LA(2) ) {
 3071  
                 case DOWN:
 3072  
                     {
 3073  0
                     switch ( input.LA(3) ) {
 3074  
                     case ABS:
 3075  
                     case BNODE:
 3076  
                     case BOUND:
 3077  
                     case CEIL:
 3078  
                     case COALESCE:
 3079  
                     case CONCAT:
 3080  
                     case CONTAINS:
 3081  
                     case DATATYPE:
 3082  
                     case DAY:
 3083  
                     case ENCODE_FOR_URI:
 3084  
                     case EXISTS:
 3085  
                     case FLOOR:
 3086  
                     case HOURS:
 3087  
                     case IF:
 3088  
                     case IRI:
 3089  
                     case ISBLANK:
 3090  
                     case ISIRI:
 3091  
                     case ISLITERAL:
 3092  
                     case ISNUMERIC:
 3093  
                     case ISURI:
 3094  
                     case LANG:
 3095  
                     case LANGMATCHES:
 3096  
                     case LCASE:
 3097  
                     case MD5:
 3098  
                     case MINUTES:
 3099  
                     case MONTH:
 3100  
                     case NOT_EXISTS:
 3101  
                     case NOW:
 3102  
                     case RAND:
 3103  
                     case REGEX:
 3104  
                     case REPLACE:
 3105  
                     case ROUND:
 3106  
                     case SAMETERM:
 3107  
                     case SECONDS:
 3108  
                     case SHA1:
 3109  
                     case SHA224:
 3110  
                     case SHA256:
 3111  
                     case SHA384:
 3112  
                     case SHA512:
 3113  
                     case STR:
 3114  
                     case STRAFTER:
 3115  
                     case STRBEFORE:
 3116  
                     case STRDT:
 3117  
                     case STRENDS:
 3118  
                     case STRLANG:
 3119  
                     case STRLEN:
 3120  
                     case STRSTARTS:
 3121  
                     case SUBSTR:
 3122  
                     case TIMEZONE:
 3123  
                     case TZ:
 3124  
                     case UCASE:
 3125  
                     case URI:
 3126  
                     case YEAR:
 3127  
                         {
 3128  0
                         alt37=1;
 3129  
                         }
 3130  0
                         break;
 3131  
                     case FUNCTION:
 3132  
                         {
 3133  0
                         alt37=2;
 3134  
                         }
 3135  0
                         break;
 3136  
                     case AND:
 3137  
                     case ASTERISK:
 3138  
                     case DECIMAL_NEGATIVE:
 3139  
                     case DECIMAL_POSITIVE:
 3140  
                     case DIVIDE:
 3141  
                     case DOUBLE_NEGATIVE:
 3142  
                     case DOUBLE_POSITIVE:
 3143  
                     case EQUAL:
 3144  
                     case GREATER:
 3145  
                     case GREATER_EQUAL:
 3146  
                     case IN:
 3147  
                     case INTEGER_NEGATIVE:
 3148  
                     case INTEGER_POSITIVE:
 3149  
                     case LESS:
 3150  
                     case LESS_EQUAL:
 3151  
                     case MINUS:
 3152  
                     case NOT:
 3153  
                     case NOT_EQUAL:
 3154  
                     case OR:
 3155  
                     case PLUS:
 3156  
                     case UNARY:
 3157  
                         {
 3158  0
                         alt37=3;
 3159  
                         }
 3160  0
                         break;
 3161  
                     case VAR1:
 3162  
                     case VAR2:
 3163  
                         {
 3164  0
                         alt37=4;
 3165  
                         }
 3166  0
                         break;
 3167  
                     default:
 3168  0
                         NoViableAltException nvae =
 3169  
                             new NoViableAltException("", 37, 2, input);
 3170  
 
 3171  0
                         throw nvae;
 3172  
 
 3173  
                     }
 3174  
 
 3175  
                     }
 3176  0
                     break;
 3177  
                 default:
 3178  0
                     NoViableAltException nvae =
 3179  
                         new NoViableAltException("", 37, 1, input);
 3180  
 
 3181  0
                     throw nvae;
 3182  
 
 3183  
                 }
 3184  
 
 3185  
                 }
 3186  0
                 break;
 3187  
             default:
 3188  0
                 NoViableAltException nvae =
 3189  
                     new NoViableAltException("", 37, 0, input);
 3190  
 
 3191  0
                 throw nvae;
 3192  
 
 3193  
             }
 3194  
 
 3195  0
             switch (alt37) {
 3196  
                 case 1 :
 3197  
                     // com\\googlecode\\sparkleg\\SparqlT.g:106:7: ^( GROUP_CONDITION builtInCall )
 3198  
                     {
 3199  0
                     root_0 = (CommonTree)adaptor.nil();
 3200  
 
 3201  
 
 3202  0
                     _last = (CommonTree)input.LT(1);
 3203  
                     {
 3204  0
                     CommonTree _save_last_1 = _last;
 3205  0
                     CommonTree _first_1 = null;
 3206  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 3207  0
                     _last = (CommonTree)input.LT(1);
 3208  0
                     GROUP_CONDITION77=(CommonTree)match(input,GROUP_CONDITION,FOLLOW_GROUP_CONDITION_in_groupCondition572); 
 3209  0
                     GROUP_CONDITION77_tree = (CommonTree)adaptor.dupNode(GROUP_CONDITION77);
 3210  
 
 3211  
 
 3212  0
                     root_1 = (CommonTree)adaptor.becomeRoot(GROUP_CONDITION77_tree, root_1);
 3213  
 
 3214  
 
 3215  0
                     match(input, Token.DOWN, null); 
 3216  0
                     _last = (CommonTree)input.LT(1);
 3217  0
                     pushFollow(FOLLOW_builtInCall_in_groupCondition574);
 3218  0
                     builtInCall78=builtInCall();
 3219  
 
 3220  0
                     state._fsp--;
 3221  
 
 3222  0
                     adaptor.addChild(root_1, builtInCall78.getTree());
 3223  
 
 3224  
 
 3225  0
                     match(input, Token.UP, null); 
 3226  0
                     adaptor.addChild(root_0, root_1);
 3227  0
                     _last = _save_last_1;
 3228  
                     }
 3229  
 
 3230  
 
 3231  
                     }
 3232  0
                     break;
 3233  
                 case 2 :
 3234  
                     // com\\googlecode\\sparkleg\\SparqlT.g:107:7: ^( GROUP_CONDITION functionCall )
 3235  
                     {
 3236  0
                     root_0 = (CommonTree)adaptor.nil();
 3237  
 
 3238  
 
 3239  0
                     _last = (CommonTree)input.LT(1);
 3240  
                     {
 3241  0
                     CommonTree _save_last_1 = _last;
 3242  0
                     CommonTree _first_1 = null;
 3243  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 3244  0
                     _last = (CommonTree)input.LT(1);
 3245  0
                     GROUP_CONDITION79=(CommonTree)match(input,GROUP_CONDITION,FOLLOW_GROUP_CONDITION_in_groupCondition584); 
 3246  0
                     GROUP_CONDITION79_tree = (CommonTree)adaptor.dupNode(GROUP_CONDITION79);
 3247  
 
 3248  
 
 3249  0
                     root_1 = (CommonTree)adaptor.becomeRoot(GROUP_CONDITION79_tree, root_1);
 3250  
 
 3251  
 
 3252  0
                     match(input, Token.DOWN, null); 
 3253  0
                     _last = (CommonTree)input.LT(1);
 3254  0
                     pushFollow(FOLLOW_functionCall_in_groupCondition586);
 3255  0
                     functionCall80=functionCall();
 3256  
 
 3257  0
                     state._fsp--;
 3258  
 
 3259  0
                     adaptor.addChild(root_1, functionCall80.getTree());
 3260  
 
 3261  
 
 3262  0
                     match(input, Token.UP, null); 
 3263  0
                     adaptor.addChild(root_0, root_1);
 3264  0
                     _last = _save_last_1;
 3265  
                     }
 3266  
 
 3267  
 
 3268  
                     }
 3269  0
                     break;
 3270  
                 case 3 :
 3271  
                     // com\\googlecode\\sparkleg\\SparqlT.g:108:7: ^( GROUP_CONDITION expression ^( AS ( var )? ) )
 3272  
                     {
 3273  0
                     root_0 = (CommonTree)adaptor.nil();
 3274  
 
 3275  
 
 3276  0
                     _last = (CommonTree)input.LT(1);
 3277  
                     {
 3278  0
                     CommonTree _save_last_1 = _last;
 3279  0
                     CommonTree _first_1 = null;
 3280  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 3281  0
                     _last = (CommonTree)input.LT(1);
 3282  0
                     GROUP_CONDITION81=(CommonTree)match(input,GROUP_CONDITION,FOLLOW_GROUP_CONDITION_in_groupCondition596); 
 3283  0
                     GROUP_CONDITION81_tree = (CommonTree)adaptor.dupNode(GROUP_CONDITION81);
 3284  
 
 3285  
 
 3286  0
                     root_1 = (CommonTree)adaptor.becomeRoot(GROUP_CONDITION81_tree, root_1);
 3287  
 
 3288  
 
 3289  0
                     match(input, Token.DOWN, null); 
 3290  0
                     _last = (CommonTree)input.LT(1);
 3291  0
                     pushFollow(FOLLOW_expression_in_groupCondition598);
 3292  0
                     expression82=expression();
 3293  
 
 3294  0
                     state._fsp--;
 3295  
 
 3296  0
                     adaptor.addChild(root_1, expression82.getTree());
 3297  
 
 3298  
 
 3299  0
                     _last = (CommonTree)input.LT(1);
 3300  
                     {
 3301  0
                     CommonTree _save_last_2 = _last;
 3302  0
                     CommonTree _first_2 = null;
 3303  0
                     CommonTree root_2 = (CommonTree)adaptor.nil();
 3304  0
                     _last = (CommonTree)input.LT(1);
 3305  0
                     AS83=(CommonTree)match(input,AS,FOLLOW_AS_in_groupCondition601); 
 3306  0
                     AS83_tree = (CommonTree)adaptor.dupNode(AS83);
 3307  
 
 3308  
 
 3309  0
                     root_2 = (CommonTree)adaptor.becomeRoot(AS83_tree, root_2);
 3310  
 
 3311  
 
 3312  0
                     if ( input.LA(1)==Token.DOWN ) {
 3313  0
                         match(input, Token.DOWN, null); 
 3314  
                         // com\\googlecode\\sparkleg\\SparqlT.g:108:41: ( var )?
 3315  0
                         int alt36=2;
 3316  0
                         switch ( input.LA(1) ) {
 3317  
                             case VAR1:
 3318  
                             case VAR2:
 3319  
                                 {
 3320  0
                                 alt36=1;
 3321  
                                 }
 3322  
                                 break;
 3323  
                         }
 3324  
 
 3325  0
                         switch (alt36) {
 3326  
                             case 1 :
 3327  
                                 // com\\googlecode\\sparkleg\\SparqlT.g:108:41: var
 3328  
                                 {
 3329  0
                                 _last = (CommonTree)input.LT(1);
 3330  0
                                 pushFollow(FOLLOW_var_in_groupCondition603);
 3331  0
                                 var84=var();
 3332  
 
 3333  0
                                 state._fsp--;
 3334  
 
 3335  0
                                 adaptor.addChild(root_2, var84.getTree());
 3336  
 
 3337  
 
 3338  
                                 }
 3339  
                                 break;
 3340  
 
 3341  
                         }
 3342  
 
 3343  
 
 3344  0
                         match(input, Token.UP, null); 
 3345  
                     }
 3346  0
                     adaptor.addChild(root_1, root_2);
 3347  0
                     _last = _save_last_2;
 3348  
                     }
 3349  
 
 3350  
 
 3351  0
                     match(input, Token.UP, null); 
 3352  0
                     adaptor.addChild(root_0, root_1);
 3353  0
                     _last = _save_last_1;
 3354  
                     }
 3355  
 
 3356  
 
 3357  
                     }
 3358  0
                     break;
 3359  
                 case 4 :
 3360  
                     // com\\googlecode\\sparkleg\\SparqlT.g:109:7: ^( GROUP_CONDITION var )
 3361  
                     {
 3362  0
                     root_0 = (CommonTree)adaptor.nil();
 3363  
 
 3364  
 
 3365  0
                     _last = (CommonTree)input.LT(1);
 3366  
                     {
 3367  0
                     CommonTree _save_last_1 = _last;
 3368  0
                     CommonTree _first_1 = null;
 3369  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 3370  0
                     _last = (CommonTree)input.LT(1);
 3371  0
                     GROUP_CONDITION85=(CommonTree)match(input,GROUP_CONDITION,FOLLOW_GROUP_CONDITION_in_groupCondition616); 
 3372  0
                     GROUP_CONDITION85_tree = (CommonTree)adaptor.dupNode(GROUP_CONDITION85);
 3373  
 
 3374  
 
 3375  0
                     root_1 = (CommonTree)adaptor.becomeRoot(GROUP_CONDITION85_tree, root_1);
 3376  
 
 3377  
 
 3378  0
                     match(input, Token.DOWN, null); 
 3379  0
                     _last = (CommonTree)input.LT(1);
 3380  0
                     pushFollow(FOLLOW_var_in_groupCondition618);
 3381  0
                     var86=var();
 3382  
 
 3383  0
                     state._fsp--;
 3384  
 
 3385  0
                     adaptor.addChild(root_1, var86.getTree());
 3386  
 
 3387  
 
 3388  0
                     match(input, Token.UP, null); 
 3389  0
                     adaptor.addChild(root_0, root_1);
 3390  0
                     _last = _save_last_1;
 3391  
                     }
 3392  
 
 3393  
 
 3394  
                     }
 3395  
                     break;
 3396  
 
 3397  
             }
 3398  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 3399  
 
 3400  
         }
 3401  0
         catch (RecognitionException re) {
 3402  0
             reportError(re);
 3403  0
             recover(input,re);
 3404  
         }
 3405  
 
 3406  0
         finally {
 3407  
                 // do for sure before leaving
 3408  0
         }
 3409  0
         return retval;
 3410  
     }
 3411  
     // $ANTLR end "groupCondition"
 3412  
 
 3413  
 
 3414  0
     public static class havingClause_return extends TreeRuleReturnScope {
 3415  
         CommonTree tree;
 3416  0
         public Object getTree() { return tree; }
 3417  
     };
 3418  
 
 3419  
 
 3420  
     // $ANTLR start "havingClause"
 3421  
     // com\\googlecode\\sparkleg\\SparqlT.g:112:1: havingClause : ^( HAVING ( constraint )+ ) ;
 3422  
     public final SparqlT.havingClause_return havingClause() throws RecognitionException {
 3423  0
         SparqlT.havingClause_return retval = new SparqlT.havingClause_return();
 3424  0
         retval.start = input.LT(1);
 3425  
 
 3426  
 
 3427  0
         CommonTree root_0 = null;
 3428  
 
 3429  0
         CommonTree _first_0 = null;
 3430  0
         CommonTree _last = null;
 3431  
 
 3432  0
         CommonTree HAVING87=null;
 3433  0
         SparqlT.constraint_return constraint88 =null;
 3434  
 
 3435  
 
 3436  0
         CommonTree HAVING87_tree=null;
 3437  
 
 3438  
         try {
 3439  
             // com\\googlecode\\sparkleg\\SparqlT.g:113:5: ( ^( HAVING ( constraint )+ ) )
 3440  
             // com\\googlecode\\sparkleg\\SparqlT.g:113:7: ^( HAVING ( constraint )+ )
 3441  
             {
 3442  0
             root_0 = (CommonTree)adaptor.nil();
 3443  
 
 3444  
 
 3445  0
             _last = (CommonTree)input.LT(1);
 3446  
             {
 3447  0
             CommonTree _save_last_1 = _last;
 3448  0
             CommonTree _first_1 = null;
 3449  0
             CommonTree root_1 = (CommonTree)adaptor.nil();
 3450  0
             _last = (CommonTree)input.LT(1);
 3451  0
             HAVING87=(CommonTree)match(input,HAVING,FOLLOW_HAVING_in_havingClause637); 
 3452  0
             HAVING87_tree = (CommonTree)adaptor.dupNode(HAVING87);
 3453  
 
 3454  
 
 3455  0
             root_1 = (CommonTree)adaptor.becomeRoot(HAVING87_tree, root_1);
 3456  
 
 3457  
 
 3458  0
             match(input, Token.DOWN, null); 
 3459  
             // com\\googlecode\\sparkleg\\SparqlT.g:113:16: ( constraint )+
 3460  0
             int cnt38=0;
 3461  
             loop38:
 3462  
             do {
 3463  0
                 int alt38=2;
 3464  0
                 switch ( input.LA(1) ) {
 3465  
                 case ABS:
 3466  
                 case AND:
 3467  
                 case ASTERISK:
 3468  
                 case BNODE:
 3469  
                 case BOUND:
 3470  
                 case CEIL:
 3471  
                 case COALESCE:
 3472  
                 case CONCAT:
 3473  
                 case CONTAINS:
 3474  
                 case DATATYPE:
 3475  
                 case DAY:
 3476  
                 case DECIMAL_NEGATIVE:
 3477  
                 case DECIMAL_POSITIVE:
 3478  
                 case DIVIDE:
 3479  
                 case DOUBLE_NEGATIVE:
 3480  
                 case DOUBLE_POSITIVE:
 3481  
                 case ENCODE_FOR_URI:
 3482  
                 case EQUAL:
 3483  
                 case EXISTS:
 3484  
                 case FLOOR:
 3485  
                 case FUNCTION:
 3486  
                 case GREATER:
 3487  
                 case GREATER_EQUAL:
 3488  
                 case HOURS:
 3489  
                 case IF:
 3490  
                 case IN:
 3491  
                 case INTEGER_NEGATIVE:
 3492  
                 case INTEGER_POSITIVE:
 3493  
                 case IRI:
 3494  
                 case ISBLANK:
 3495  
                 case ISIRI:
 3496  
                 case ISLITERAL:
 3497  
                 case ISNUMERIC:
 3498  
                 case ISURI:
 3499  
                 case LANG:
 3500  
                 case LANGMATCHES:
 3501  
                 case LCASE:
 3502  
                 case LESS:
 3503  
                 case LESS_EQUAL:
 3504  
                 case MD5:
 3505  
                 case MINUS:
 3506  
                 case MINUTES:
 3507  
                 case MONTH:
 3508  
                 case NOT:
 3509  
                 case NOT_EQUAL:
 3510  
                 case NOT_EXISTS:
 3511  
                 case NOW:
 3512  
                 case OR:
 3513  
                 case PLUS:
 3514  
                 case RAND:
 3515  
                 case REGEX:
 3516  
                 case REPLACE:
 3517  
                 case ROUND:
 3518  
                 case SAMETERM:
 3519  
                 case SECONDS:
 3520  
                 case SHA1:
 3521  
                 case SHA224:
 3522  
                 case SHA256:
 3523  
                 case SHA384:
 3524  
                 case SHA512:
 3525  
                 case STR:
 3526  
                 case STRAFTER:
 3527  
                 case STRBEFORE:
 3528  
                 case STRDT:
 3529  
                 case STRENDS:
 3530  
                 case STRLANG:
 3531  
                 case STRLEN:
 3532  
                 case STRSTARTS:
 3533  
                 case SUBSTR:
 3534  
                 case TIMEZONE:
 3535  
                 case TZ:
 3536  
                 case UCASE:
 3537  
                 case UNARY:
 3538  
                 case URI:
 3539  
                 case YEAR:
 3540  
                     {
 3541  0
                     alt38=1;
 3542  
                     }
 3543  
                     break;
 3544  
 
 3545  
                 }
 3546  
 
 3547  0
                 switch (alt38) {
 3548  
                     case 1 :
 3549  
                         // com\\googlecode\\sparkleg\\SparqlT.g:113:16: constraint
 3550  
                         {
 3551  0
                         _last = (CommonTree)input.LT(1);
 3552  0
                         pushFollow(FOLLOW_constraint_in_havingClause639);
 3553  0
                         constraint88=constraint();
 3554  
 
 3555  0
                         state._fsp--;
 3556  
 
 3557  0
                         adaptor.addChild(root_1, constraint88.getTree());
 3558  
 
 3559  
 
 3560  
                         }
 3561  0
                         break;
 3562  
 
 3563  
                     default :
 3564  0
                         if ( cnt38 >= 1 ) break loop38;
 3565  0
                         EarlyExitException eee =
 3566  
                             new EarlyExitException(38, input);
 3567  0
                         throw eee;
 3568  
                 }
 3569  0
                 cnt38++;
 3570  0
             } while (true);
 3571  
 
 3572  
 
 3573  0
             match(input, Token.UP, null); 
 3574  0
             adaptor.addChild(root_0, root_1);
 3575  0
             _last = _save_last_1;
 3576  
             }
 3577  
 
 3578  
 
 3579  
             }
 3580  
 
 3581  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 3582  
 
 3583  
         }
 3584  0
         catch (RecognitionException re) {
 3585  0
             reportError(re);
 3586  0
             recover(input,re);
 3587  
         }
 3588  
 
 3589  0
         finally {
 3590  
                 // do for sure before leaving
 3591  0
         }
 3592  0
         return retval;
 3593  
     }
 3594  
     // $ANTLR end "havingClause"
 3595  
 
 3596  
 
 3597  0
     public static class orderClause_return extends TreeRuleReturnScope {
 3598  
         CommonTree tree;
 3599  0
         public Object getTree() { return tree; }
 3600  
     };
 3601  
 
 3602  
 
 3603  
     // $ANTLR start "orderClause"
 3604  
     // com\\googlecode\\sparkleg\\SparqlT.g:116:1: orderClause : ^( ORDER_BY ( orderCondition )+ ) ;
 3605  
     public final SparqlT.orderClause_return orderClause() throws RecognitionException {
 3606  0
         SparqlT.orderClause_return retval = new SparqlT.orderClause_return();
 3607  0
         retval.start = input.LT(1);
 3608  
 
 3609  
 
 3610  0
         CommonTree root_0 = null;
 3611  
 
 3612  0
         CommonTree _first_0 = null;
 3613  0
         CommonTree _last = null;
 3614  
 
 3615  0
         CommonTree ORDER_BY89=null;
 3616  0
         SparqlT.orderCondition_return orderCondition90 =null;
 3617  
 
 3618  
 
 3619  0
         CommonTree ORDER_BY89_tree=null;
 3620  
 
 3621  
         try {
 3622  
             // com\\googlecode\\sparkleg\\SparqlT.g:117:5: ( ^( ORDER_BY ( orderCondition )+ ) )
 3623  
             // com\\googlecode\\sparkleg\\SparqlT.g:117:7: ^( ORDER_BY ( orderCondition )+ )
 3624  
             {
 3625  0
             root_0 = (CommonTree)adaptor.nil();
 3626  
 
 3627  
 
 3628  0
             _last = (CommonTree)input.LT(1);
 3629  
             {
 3630  0
             CommonTree _save_last_1 = _last;
 3631  0
             CommonTree _first_1 = null;
 3632  0
             CommonTree root_1 = (CommonTree)adaptor.nil();
 3633  0
             _last = (CommonTree)input.LT(1);
 3634  0
             ORDER_BY89=(CommonTree)match(input,ORDER_BY,FOLLOW_ORDER_BY_in_orderClause664); 
 3635  0
             ORDER_BY89_tree = (CommonTree)adaptor.dupNode(ORDER_BY89);
 3636  
 
 3637  
 
 3638  0
             root_1 = (CommonTree)adaptor.becomeRoot(ORDER_BY89_tree, root_1);
 3639  
 
 3640  
 
 3641  0
             match(input, Token.DOWN, null); 
 3642  
             // com\\googlecode\\sparkleg\\SparqlT.g:117:18: ( orderCondition )+
 3643  0
             int cnt39=0;
 3644  
             loop39:
 3645  
             do {
 3646  0
                 int alt39=2;
 3647  0
                 switch ( input.LA(1) ) {
 3648  
                 case ORDER_CONDITION:
 3649  
                     {
 3650  0
                     alt39=1;
 3651  
                     }
 3652  
                     break;
 3653  
 
 3654  
                 }
 3655  
 
 3656  0
                 switch (alt39) {
 3657  
                     case 1 :
 3658  
                         // com\\googlecode\\sparkleg\\SparqlT.g:117:18: orderCondition
 3659  
                         {
 3660  0
                         _last = (CommonTree)input.LT(1);
 3661  0
                         pushFollow(FOLLOW_orderCondition_in_orderClause666);
 3662  0
                         orderCondition90=orderCondition();
 3663  
 
 3664  0
                         state._fsp--;
 3665  
 
 3666  0
                         adaptor.addChild(root_1, orderCondition90.getTree());
 3667  
 
 3668  
 
 3669  
                         }
 3670  0
                         break;
 3671  
 
 3672  
                     default :
 3673  0
                         if ( cnt39 >= 1 ) break loop39;
 3674  0
                         EarlyExitException eee =
 3675  
                             new EarlyExitException(39, input);
 3676  0
                         throw eee;
 3677  
                 }
 3678  0
                 cnt39++;
 3679  0
             } while (true);
 3680  
 
 3681  
 
 3682  0
             match(input, Token.UP, null); 
 3683  0
             adaptor.addChild(root_0, root_1);
 3684  0
             _last = _save_last_1;
 3685  
             }
 3686  
 
 3687  
 
 3688  
             }
 3689  
 
 3690  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 3691  
 
 3692  
         }
 3693  0
         catch (RecognitionException re) {
 3694  0
             reportError(re);
 3695  0
             recover(input,re);
 3696  
         }
 3697  
 
 3698  0
         finally {
 3699  
                 // do for sure before leaving
 3700  0
         }
 3701  0
         return retval;
 3702  
     }
 3703  
     // $ANTLR end "orderClause"
 3704  
 
 3705  
 
 3706  0
     public static class orderCondition_return extends TreeRuleReturnScope {
 3707  
         CommonTree tree;
 3708  0
         public Object getTree() { return tree; }
 3709  
     };
 3710  
 
 3711  
 
 3712  
     // $ANTLR start "orderCondition"
 3713  
     // com\\googlecode\\sparkleg\\SparqlT.g:120:1: orderCondition : ( ^( ORDER_CONDITION ASC expression ) | ^( ORDER_CONDITION DESC expression ) | ^( ORDER_CONDITION constraint ) | ^( ORDER_CONDITION var ) );
 3714  
     public final SparqlT.orderCondition_return orderCondition() throws RecognitionException {
 3715  0
         SparqlT.orderCondition_return retval = new SparqlT.orderCondition_return();
 3716  0
         retval.start = input.LT(1);
 3717  
 
 3718  
 
 3719  0
         CommonTree root_0 = null;
 3720  
 
 3721  0
         CommonTree _first_0 = null;
 3722  0
         CommonTree _last = null;
 3723  
 
 3724  0
         CommonTree ORDER_CONDITION91=null;
 3725  0
         CommonTree ASC92=null;
 3726  0
         CommonTree ORDER_CONDITION94=null;
 3727  0
         CommonTree DESC95=null;
 3728  0
         CommonTree ORDER_CONDITION97=null;
 3729  0
         CommonTree ORDER_CONDITION99=null;
 3730  0
         SparqlT.expression_return expression93 =null;
 3731  
 
 3732  0
         SparqlT.expression_return expression96 =null;
 3733  
 
 3734  0
         SparqlT.constraint_return constraint98 =null;
 3735  
 
 3736  0
         SparqlT.var_return var100 =null;
 3737  
 
 3738  
 
 3739  0
         CommonTree ORDER_CONDITION91_tree=null;
 3740  0
         CommonTree ASC92_tree=null;
 3741  0
         CommonTree ORDER_CONDITION94_tree=null;
 3742  0
         CommonTree DESC95_tree=null;
 3743  0
         CommonTree ORDER_CONDITION97_tree=null;
 3744  0
         CommonTree ORDER_CONDITION99_tree=null;
 3745  
 
 3746  
         try {
 3747  
             // com\\googlecode\\sparkleg\\SparqlT.g:121:5: ( ^( ORDER_CONDITION ASC expression ) | ^( ORDER_CONDITION DESC expression ) | ^( ORDER_CONDITION constraint ) | ^( ORDER_CONDITION var ) )
 3748  0
             int alt40=4;
 3749  0
             switch ( input.LA(1) ) {
 3750  
             case ORDER_CONDITION:
 3751  
                 {
 3752  0
                 switch ( input.LA(2) ) {
 3753  
                 case DOWN:
 3754  
                     {
 3755  0
                     switch ( input.LA(3) ) {
 3756  
                     case ASC:
 3757  
                         {
 3758  0
                         alt40=1;
 3759  
                         }
 3760  0
                         break;
 3761  
                     case DESC:
 3762  
                         {
 3763  0
                         alt40=2;
 3764  
                         }
 3765  0
                         break;
 3766  
                     case ABS:
 3767  
                     case AND:
 3768  
                     case ASTERISK:
 3769  
                     case BNODE:
 3770  
                     case BOUND:
 3771  
                     case CEIL:
 3772  
                     case COALESCE:
 3773  
                     case CONCAT:
 3774  
                     case CONTAINS:
 3775  
                     case DATATYPE:
 3776  
                     case DAY:
 3777  
                     case DECIMAL_NEGATIVE:
 3778  
                     case DECIMAL_POSITIVE:
 3779  
                     case DIVIDE:
 3780  
                     case DOUBLE_NEGATIVE:
 3781  
                     case DOUBLE_POSITIVE:
 3782  
                     case ENCODE_FOR_URI:
 3783  
                     case EQUAL:
 3784  
                     case EXISTS:
 3785  
                     case FLOOR:
 3786  
                     case FUNCTION:
 3787  
                     case GREATER:
 3788  
                     case GREATER_EQUAL:
 3789  
                     case HOURS:
 3790  
                     case IF:
 3791  
                     case IN:
 3792  
                     case INTEGER_NEGATIVE:
 3793  
                     case INTEGER_POSITIVE:
 3794  
                     case IRI:
 3795  
                     case ISBLANK:
 3796  
                     case ISIRI:
 3797  
                     case ISLITERAL:
 3798  
                     case ISNUMERIC:
 3799  
                     case ISURI:
 3800  
                     case LANG:
 3801  
                     case LANGMATCHES:
 3802  
                     case LCASE:
 3803  
                     case LESS:
 3804  
                     case LESS_EQUAL:
 3805  
                     case MD5:
 3806  
                     case MINUS:
 3807  
                     case MINUTES:
 3808  
                     case MONTH:
 3809  
                     case NOT:
 3810  
                     case NOT_EQUAL:
 3811  
                     case NOT_EXISTS:
 3812  
                     case NOW:
 3813  
                     case OR:
 3814  
                     case PLUS:
 3815  
                     case RAND:
 3816  
                     case REGEX:
 3817  
                     case REPLACE:
 3818  
                     case ROUND:
 3819  
                     case SAMETERM:
 3820  
                     case SECONDS:
 3821  
                     case SHA1:
 3822  
                     case SHA224:
 3823  
                     case SHA256:
 3824  
                     case SHA384:
 3825  
                     case SHA512:
 3826  
                     case STR:
 3827  
                     case STRAFTER:
 3828  
                     case STRBEFORE:
 3829  
                     case STRDT:
 3830  
                     case STRENDS:
 3831  
                     case STRLANG:
 3832  
                     case STRLEN:
 3833  
                     case STRSTARTS:
 3834  
                     case SUBSTR:
 3835  
                     case TIMEZONE:
 3836  
                     case TZ:
 3837  
                     case UCASE:
 3838  
                     case UNARY:
 3839  
                     case URI:
 3840  
                     case YEAR:
 3841  
                         {
 3842  0
                         alt40=3;
 3843  
                         }
 3844  0
                         break;
 3845  
                     case VAR1:
 3846  
                     case VAR2:
 3847  
                         {
 3848  0
                         alt40=4;
 3849  
                         }
 3850  0
                         break;
 3851  
                     default:
 3852  0
                         NoViableAltException nvae =
 3853  
                             new NoViableAltException("", 40, 2, input);
 3854  
 
 3855  0
                         throw nvae;
 3856  
 
 3857  
                     }
 3858  
 
 3859  
                     }
 3860  0
                     break;
 3861  
                 default:
 3862  0
                     NoViableAltException nvae =
 3863  
                         new NoViableAltException("", 40, 1, input);
 3864  
 
 3865  0
                     throw nvae;
 3866  
 
 3867  
                 }
 3868  
 
 3869  
                 }
 3870  0
                 break;
 3871  
             default:
 3872  0
                 NoViableAltException nvae =
 3873  
                     new NoViableAltException("", 40, 0, input);
 3874  
 
 3875  0
                 throw nvae;
 3876  
 
 3877  
             }
 3878  
 
 3879  0
             switch (alt40) {
 3880  
                 case 1 :
 3881  
                     // com\\googlecode\\sparkleg\\SparqlT.g:121:7: ^( ORDER_CONDITION ASC expression )
 3882  
                     {
 3883  0
                     root_0 = (CommonTree)adaptor.nil();
 3884  
 
 3885  
 
 3886  0
                     _last = (CommonTree)input.LT(1);
 3887  
                     {
 3888  0
                     CommonTree _save_last_1 = _last;
 3889  0
                     CommonTree _first_1 = null;
 3890  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 3891  0
                     _last = (CommonTree)input.LT(1);
 3892  0
                     ORDER_CONDITION91=(CommonTree)match(input,ORDER_CONDITION,FOLLOW_ORDER_CONDITION_in_orderCondition686); 
 3893  0
                     ORDER_CONDITION91_tree = (CommonTree)adaptor.dupNode(ORDER_CONDITION91);
 3894  
 
 3895  
 
 3896  0
                     root_1 = (CommonTree)adaptor.becomeRoot(ORDER_CONDITION91_tree, root_1);
 3897  
 
 3898  
 
 3899  0
                     match(input, Token.DOWN, null); 
 3900  0
                     _last = (CommonTree)input.LT(1);
 3901  0
                     ASC92=(CommonTree)match(input,ASC,FOLLOW_ASC_in_orderCondition688); 
 3902  0
                     ASC92_tree = (CommonTree)adaptor.dupNode(ASC92);
 3903  
 
 3904  
 
 3905  0
                     adaptor.addChild(root_1, ASC92_tree);
 3906  
 
 3907  
 
 3908  0
                     _last = (CommonTree)input.LT(1);
 3909  0
                     pushFollow(FOLLOW_expression_in_orderCondition690);
 3910  0
                     expression93=expression();
 3911  
 
 3912  0
                     state._fsp--;
 3913  
 
 3914  0
                     adaptor.addChild(root_1, expression93.getTree());
 3915  
 
 3916  
 
 3917  0
                     match(input, Token.UP, null); 
 3918  0
                     adaptor.addChild(root_0, root_1);
 3919  0
                     _last = _save_last_1;
 3920  
                     }
 3921  
 
 3922  
 
 3923  
                     }
 3924  0
                     break;
 3925  
                 case 2 :
 3926  
                     // com\\googlecode\\sparkleg\\SparqlT.g:122:7: ^( ORDER_CONDITION DESC expression )
 3927  
                     {
 3928  0
                     root_0 = (CommonTree)adaptor.nil();
 3929  
 
 3930  
 
 3931  0
                     _last = (CommonTree)input.LT(1);
 3932  
                     {
 3933  0
                     CommonTree _save_last_1 = _last;
 3934  0
                     CommonTree _first_1 = null;
 3935  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 3936  0
                     _last = (CommonTree)input.LT(1);
 3937  0
                     ORDER_CONDITION94=(CommonTree)match(input,ORDER_CONDITION,FOLLOW_ORDER_CONDITION_in_orderCondition700); 
 3938  0
                     ORDER_CONDITION94_tree = (CommonTree)adaptor.dupNode(ORDER_CONDITION94);
 3939  
 
 3940  
 
 3941  0
                     root_1 = (CommonTree)adaptor.becomeRoot(ORDER_CONDITION94_tree, root_1);
 3942  
 
 3943  
 
 3944  0
                     match(input, Token.DOWN, null); 
 3945  0
                     _last = (CommonTree)input.LT(1);
 3946  0
                     DESC95=(CommonTree)match(input,DESC,FOLLOW_DESC_in_orderCondition702); 
 3947  0
                     DESC95_tree = (CommonTree)adaptor.dupNode(DESC95);
 3948  
 
 3949  
 
 3950  0
                     adaptor.addChild(root_1, DESC95_tree);
 3951  
 
 3952  
 
 3953  0
                     _last = (CommonTree)input.LT(1);
 3954  0
                     pushFollow(FOLLOW_expression_in_orderCondition704);
 3955  0
                     expression96=expression();
 3956  
 
 3957  0
                     state._fsp--;
 3958  
 
 3959  0
                     adaptor.addChild(root_1, expression96.getTree());
 3960  
 
 3961  
 
 3962  0
                     match(input, Token.UP, null); 
 3963  0
                     adaptor.addChild(root_0, root_1);
 3964  0
                     _last = _save_last_1;
 3965  
                     }
 3966  
 
 3967  
 
 3968  
                     }
 3969  0
                     break;
 3970  
                 case 3 :
 3971  
                     // com\\googlecode\\sparkleg\\SparqlT.g:123:7: ^( ORDER_CONDITION constraint )
 3972  
                     {
 3973  0
                     root_0 = (CommonTree)adaptor.nil();
 3974  
 
 3975  
 
 3976  0
                     _last = (CommonTree)input.LT(1);
 3977  
                     {
 3978  0
                     CommonTree _save_last_1 = _last;
 3979  0
                     CommonTree _first_1 = null;
 3980  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 3981  0
                     _last = (CommonTree)input.LT(1);
 3982  0
                     ORDER_CONDITION97=(CommonTree)match(input,ORDER_CONDITION,FOLLOW_ORDER_CONDITION_in_orderCondition714); 
 3983  0
                     ORDER_CONDITION97_tree = (CommonTree)adaptor.dupNode(ORDER_CONDITION97);
 3984  
 
 3985  
 
 3986  0
                     root_1 = (CommonTree)adaptor.becomeRoot(ORDER_CONDITION97_tree, root_1);
 3987  
 
 3988  
 
 3989  0
                     match(input, Token.DOWN, null); 
 3990  0
                     _last = (CommonTree)input.LT(1);
 3991  0
                     pushFollow(FOLLOW_constraint_in_orderCondition716);
 3992  0
                     constraint98=constraint();
 3993  
 
 3994  0
                     state._fsp--;
 3995  
 
 3996  0
                     adaptor.addChild(root_1, constraint98.getTree());
 3997  
 
 3998  
 
 3999  0
                     match(input, Token.UP, null); 
 4000  0
                     adaptor.addChild(root_0, root_1);
 4001  0
                     _last = _save_last_1;
 4002  
                     }
 4003  
 
 4004  
 
 4005  
                     }
 4006  0
                     break;
 4007  
                 case 4 :
 4008  
                     // com\\googlecode\\sparkleg\\SparqlT.g:124:7: ^( ORDER_CONDITION var )
 4009  
                     {
 4010  0
                     root_0 = (CommonTree)adaptor.nil();
 4011  
 
 4012  
 
 4013  0
                     _last = (CommonTree)input.LT(1);
 4014  
                     {
 4015  0
                     CommonTree _save_last_1 = _last;
 4016  0
                     CommonTree _first_1 = null;
 4017  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 4018  0
                     _last = (CommonTree)input.LT(1);
 4019  0
                     ORDER_CONDITION99=(CommonTree)match(input,ORDER_CONDITION,FOLLOW_ORDER_CONDITION_in_orderCondition726); 
 4020  0
                     ORDER_CONDITION99_tree = (CommonTree)adaptor.dupNode(ORDER_CONDITION99);
 4021  
 
 4022  
 
 4023  0
                     root_1 = (CommonTree)adaptor.becomeRoot(ORDER_CONDITION99_tree, root_1);
 4024  
 
 4025  
 
 4026  0
                     match(input, Token.DOWN, null); 
 4027  0
                     _last = (CommonTree)input.LT(1);
 4028  0
                     pushFollow(FOLLOW_var_in_orderCondition728);
 4029  0
                     var100=var();
 4030  
 
 4031  0
                     state._fsp--;
 4032  
 
 4033  0
                     adaptor.addChild(root_1, var100.getTree());
 4034  
 
 4035  
 
 4036  0
                     match(input, Token.UP, null); 
 4037  0
                     adaptor.addChild(root_0, root_1);
 4038  0
                     _last = _save_last_1;
 4039  
                     }
 4040  
 
 4041  
 
 4042  
                     }
 4043  
                     break;
 4044  
 
 4045  
             }
 4046  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 4047  
 
 4048  
         }
 4049  0
         catch (RecognitionException re) {
 4050  0
             reportError(re);
 4051  0
             recover(input,re);
 4052  
         }
 4053  
 
 4054  0
         finally {
 4055  
                 // do for sure before leaving
 4056  0
         }
 4057  0
         return retval;
 4058  
     }
 4059  
     // $ANTLR end "orderCondition"
 4060  
 
 4061  
 
 4062  0
     public static class limitOffsetClauses_return extends TreeRuleReturnScope {
 4063  
         CommonTree tree;
 4064  0
         public Object getTree() { return tree; }
 4065  
     };
 4066  
 
 4067  
 
 4068  
     // $ANTLR start "limitOffsetClauses"
 4069  
     // com\\googlecode\\sparkleg\\SparqlT.g:127:1: limitOffsetClauses : ( ^( LIMIT INTEGER ) ( ^( OFFSET INTEGER ) )* | ^( OFFSET INTEGER ) ( ^( LIMIT INTEGER ) )* );
 4070  
     public final SparqlT.limitOffsetClauses_return limitOffsetClauses() throws RecognitionException {
 4071  0
         SparqlT.limitOffsetClauses_return retval = new SparqlT.limitOffsetClauses_return();
 4072  0
         retval.start = input.LT(1);
 4073  
 
 4074  
 
 4075  0
         CommonTree root_0 = null;
 4076  
 
 4077  0
         CommonTree _first_0 = null;
 4078  0
         CommonTree _last = null;
 4079  
 
 4080  0
         CommonTree LIMIT101=null;
 4081  0
         CommonTree INTEGER102=null;
 4082  0
         CommonTree OFFSET103=null;
 4083  0
         CommonTree INTEGER104=null;
 4084  0
         CommonTree OFFSET105=null;
 4085  0
         CommonTree INTEGER106=null;
 4086  0
         CommonTree LIMIT107=null;
 4087  0
         CommonTree INTEGER108=null;
 4088  
 
 4089  0
         CommonTree LIMIT101_tree=null;
 4090  0
         CommonTree INTEGER102_tree=null;
 4091  0
         CommonTree OFFSET103_tree=null;
 4092  0
         CommonTree INTEGER104_tree=null;
 4093  0
         CommonTree OFFSET105_tree=null;
 4094  0
         CommonTree INTEGER106_tree=null;
 4095  0
         CommonTree LIMIT107_tree=null;
 4096  0
         CommonTree INTEGER108_tree=null;
 4097  
 
 4098  
         try {
 4099  
             // com\\googlecode\\sparkleg\\SparqlT.g:128:5: ( ^( LIMIT INTEGER ) ( ^( OFFSET INTEGER ) )* | ^( OFFSET INTEGER ) ( ^( LIMIT INTEGER ) )* )
 4100  0
             int alt43=2;
 4101  0
             switch ( input.LA(1) ) {
 4102  
             case LIMIT:
 4103  
                 {
 4104  0
                 alt43=1;
 4105  
                 }
 4106  0
                 break;
 4107  
             case OFFSET:
 4108  
                 {
 4109  0
                 alt43=2;
 4110  
                 }
 4111  0
                 break;
 4112  
             default:
 4113  0
                 NoViableAltException nvae =
 4114  
                     new NoViableAltException("", 43, 0, input);
 4115  
 
 4116  0
                 throw nvae;
 4117  
 
 4118  
             }
 4119  
 
 4120  0
             switch (alt43) {
 4121  
                 case 1 :
 4122  
                     // com\\googlecode\\sparkleg\\SparqlT.g:128:7: ^( LIMIT INTEGER ) ( ^( OFFSET INTEGER ) )*
 4123  
                     {
 4124  0
                     root_0 = (CommonTree)adaptor.nil();
 4125  
 
 4126  
 
 4127  0
                     _last = (CommonTree)input.LT(1);
 4128  
                     {
 4129  0
                     CommonTree _save_last_1 = _last;
 4130  0
                     CommonTree _first_1 = null;
 4131  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 4132  0
                     _last = (CommonTree)input.LT(1);
 4133  0
                     LIMIT101=(CommonTree)match(input,LIMIT,FOLLOW_LIMIT_in_limitOffsetClauses752); 
 4134  0
                     LIMIT101_tree = (CommonTree)adaptor.dupNode(LIMIT101);
 4135  
 
 4136  
 
 4137  0
                     root_1 = (CommonTree)adaptor.becomeRoot(LIMIT101_tree, root_1);
 4138  
 
 4139  
 
 4140  0
                     match(input, Token.DOWN, null); 
 4141  0
                     _last = (CommonTree)input.LT(1);
 4142  0
                     INTEGER102=(CommonTree)match(input,INTEGER,FOLLOW_INTEGER_in_limitOffsetClauses754); 
 4143  0
                     INTEGER102_tree = (CommonTree)adaptor.dupNode(INTEGER102);
 4144  
 
 4145  
 
 4146  0
                     adaptor.addChild(root_1, INTEGER102_tree);
 4147  
 
 4148  
 
 4149  0
                     match(input, Token.UP, null); 
 4150  0
                     adaptor.addChild(root_0, root_1);
 4151  0
                     _last = _save_last_1;
 4152  
                     }
 4153  
 
 4154  
 
 4155  
                     // com\\googlecode\\sparkleg\\SparqlT.g:128:24: ( ^( OFFSET INTEGER ) )*
 4156  
                     loop41:
 4157  
                     do {
 4158  0
                         int alt41=2;
 4159  0
                         switch ( input.LA(1) ) {
 4160  
                         case OFFSET:
 4161  
                             {
 4162  0
                             alt41=1;
 4163  
                             }
 4164  
                             break;
 4165  
 
 4166  
                         }
 4167  
 
 4168  0
                         switch (alt41) {
 4169  
                             case 1 :
 4170  
                                 // com\\googlecode\\sparkleg\\SparqlT.g:128:25: ^( OFFSET INTEGER )
 4171  
                                 {
 4172  0
                                 _last = (CommonTree)input.LT(1);
 4173  
                                 {
 4174  0
                                 CommonTree _save_last_1 = _last;
 4175  0
                                 CommonTree _first_1 = null;
 4176  0
                                 CommonTree root_1 = (CommonTree)adaptor.nil();
 4177  0
                                 _last = (CommonTree)input.LT(1);
 4178  0
                                 OFFSET103=(CommonTree)match(input,OFFSET,FOLLOW_OFFSET_in_limitOffsetClauses759); 
 4179  0
                                 OFFSET103_tree = (CommonTree)adaptor.dupNode(OFFSET103);
 4180  
 
 4181  
 
 4182  0
                                 root_1 = (CommonTree)adaptor.becomeRoot(OFFSET103_tree, root_1);
 4183  
 
 4184  
 
 4185  0
                                 match(input, Token.DOWN, null); 
 4186  0
                                 _last = (CommonTree)input.LT(1);
 4187  0
                                 INTEGER104=(CommonTree)match(input,INTEGER,FOLLOW_INTEGER_in_limitOffsetClauses761); 
 4188  0
                                 INTEGER104_tree = (CommonTree)adaptor.dupNode(INTEGER104);
 4189  
 
 4190  
 
 4191  0
                                 adaptor.addChild(root_1, INTEGER104_tree);
 4192  
 
 4193  
 
 4194  0
                                 match(input, Token.UP, null); 
 4195  0
                                 adaptor.addChild(root_0, root_1);
 4196  0
                                 _last = _save_last_1;
 4197  
                                 }
 4198  
 
 4199  
 
 4200  
                                 }
 4201  0
                                 break;
 4202  
 
 4203  
                             default :
 4204  0
                                 break loop41;
 4205  
                         }
 4206  0
                     } while (true);
 4207  
 
 4208  
 
 4209  
                     }
 4210  
                     break;
 4211  
                 case 2 :
 4212  
                     // com\\googlecode\\sparkleg\\SparqlT.g:129:7: ^( OFFSET INTEGER ) ( ^( LIMIT INTEGER ) )*
 4213  
                     {
 4214  0
                     root_0 = (CommonTree)adaptor.nil();
 4215  
 
 4216  
 
 4217  0
                     _last = (CommonTree)input.LT(1);
 4218  
                     {
 4219  0
                     CommonTree _save_last_1 = _last;
 4220  0
                     CommonTree _first_1 = null;
 4221  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 4222  0
                     _last = (CommonTree)input.LT(1);
 4223  0
                     OFFSET105=(CommonTree)match(input,OFFSET,FOLLOW_OFFSET_in_limitOffsetClauses773); 
 4224  0
                     OFFSET105_tree = (CommonTree)adaptor.dupNode(OFFSET105);
 4225  
 
 4226  
 
 4227  0
                     root_1 = (CommonTree)adaptor.becomeRoot(OFFSET105_tree, root_1);
 4228  
 
 4229  
 
 4230  0
                     match(input, Token.DOWN, null); 
 4231  0
                     _last = (CommonTree)input.LT(1);
 4232  0
                     INTEGER106=(CommonTree)match(input,INTEGER,FOLLOW_INTEGER_in_limitOffsetClauses775); 
 4233  0
                     INTEGER106_tree = (CommonTree)adaptor.dupNode(INTEGER106);
 4234  
 
 4235  
 
 4236  0
                     adaptor.addChild(root_1, INTEGER106_tree);
 4237  
 
 4238  
 
 4239  0
                     match(input, Token.UP, null); 
 4240  0
                     adaptor.addChild(root_0, root_1);
 4241  0
                     _last = _save_last_1;
 4242  
                     }
 4243  
 
 4244  
 
 4245  
                     // com\\googlecode\\sparkleg\\SparqlT.g:129:25: ( ^( LIMIT INTEGER ) )*
 4246  
                     loop42:
 4247  
                     do {
 4248  0
                         int alt42=2;
 4249  0
                         switch ( input.LA(1) ) {
 4250  
                         case LIMIT:
 4251  
                             {
 4252  0
                             alt42=1;
 4253  
                             }
 4254  
                             break;
 4255  
 
 4256  
                         }
 4257  
 
 4258  0
                         switch (alt42) {
 4259  
                             case 1 :
 4260  
                                 // com\\googlecode\\sparkleg\\SparqlT.g:129:26: ^( LIMIT INTEGER )
 4261  
                                 {
 4262  0
                                 _last = (CommonTree)input.LT(1);
 4263  
                                 {
 4264  0
                                 CommonTree _save_last_1 = _last;
 4265  0
                                 CommonTree _first_1 = null;
 4266  0
                                 CommonTree root_1 = (CommonTree)adaptor.nil();
 4267  0
                                 _last = (CommonTree)input.LT(1);
 4268  0
                                 LIMIT107=(CommonTree)match(input,LIMIT,FOLLOW_LIMIT_in_limitOffsetClauses780); 
 4269  0
                                 LIMIT107_tree = (CommonTree)adaptor.dupNode(LIMIT107);
 4270  
 
 4271  
 
 4272  0
                                 root_1 = (CommonTree)adaptor.becomeRoot(LIMIT107_tree, root_1);
 4273  
 
 4274  
 
 4275  0
                                 match(input, Token.DOWN, null); 
 4276  0
                                 _last = (CommonTree)input.LT(1);
 4277  0
                                 INTEGER108=(CommonTree)match(input,INTEGER,FOLLOW_INTEGER_in_limitOffsetClauses782); 
 4278  0
                                 INTEGER108_tree = (CommonTree)adaptor.dupNode(INTEGER108);
 4279  
 
 4280  
 
 4281  0
                                 adaptor.addChild(root_1, INTEGER108_tree);
 4282  
 
 4283  
 
 4284  0
                                 match(input, Token.UP, null); 
 4285  0
                                 adaptor.addChild(root_0, root_1);
 4286  0
                                 _last = _save_last_1;
 4287  
                                 }
 4288  
 
 4289  
 
 4290  
                                 }
 4291  0
                                 break;
 4292  
 
 4293  
                             default :
 4294  0
                                 break loop42;
 4295  
                         }
 4296  0
                     } while (true);
 4297  
 
 4298  
 
 4299  
                     }
 4300  
                     break;
 4301  
 
 4302  
             }
 4303  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 4304  
 
 4305  
         }
 4306  0
         catch (RecognitionException re) {
 4307  0
             reportError(re);
 4308  0
             recover(input,re);
 4309  
         }
 4310  
 
 4311  0
         finally {
 4312  
                 // do for sure before leaving
 4313  0
         }
 4314  0
         return retval;
 4315  
     }
 4316  
     // $ANTLR end "limitOffsetClauses"
 4317  
 
 4318  
 
 4319  0
     public static class bindingsClause_return extends TreeRuleReturnScope {
 4320  
         CommonTree tree;
 4321  0
         public Object getTree() { return tree; }
 4322  
     };
 4323  
 
 4324  
 
 4325  
     // $ANTLR start "bindingsClause"
 4326  
     // com\\googlecode\\sparkleg\\SparqlT.g:133:1: bindingsClause : ^( BINDINGS ( var )* ( bindingValueList )* ) ;
 4327  
     public final SparqlT.bindingsClause_return bindingsClause() throws RecognitionException {
 4328  0
         SparqlT.bindingsClause_return retval = new SparqlT.bindingsClause_return();
 4329  0
         retval.start = input.LT(1);
 4330  
 
 4331  
 
 4332  0
         CommonTree root_0 = null;
 4333  
 
 4334  0
         CommonTree _first_0 = null;
 4335  0
         CommonTree _last = null;
 4336  
 
 4337  0
         CommonTree BINDINGS109=null;
 4338  0
         SparqlT.var_return var110 =null;
 4339  
 
 4340  0
         SparqlT.bindingValueList_return bindingValueList111 =null;
 4341  
 
 4342  
 
 4343  0
         CommonTree BINDINGS109_tree=null;
 4344  
 
 4345  
         try {
 4346  
             // com\\googlecode\\sparkleg\\SparqlT.g:134:5: ( ^( BINDINGS ( var )* ( bindingValueList )* ) )
 4347  
             // com\\googlecode\\sparkleg\\SparqlT.g:134:7: ^( BINDINGS ( var )* ( bindingValueList )* )
 4348  
             {
 4349  0
             root_0 = (CommonTree)adaptor.nil();
 4350  
 
 4351  
 
 4352  0
             _last = (CommonTree)input.LT(1);
 4353  
             {
 4354  0
             CommonTree _save_last_1 = _last;
 4355  0
             CommonTree _first_1 = null;
 4356  0
             CommonTree root_1 = (CommonTree)adaptor.nil();
 4357  0
             _last = (CommonTree)input.LT(1);
 4358  0
             BINDINGS109=(CommonTree)match(input,BINDINGS,FOLLOW_BINDINGS_in_bindingsClause804); 
 4359  0
             BINDINGS109_tree = (CommonTree)adaptor.dupNode(BINDINGS109);
 4360  
 
 4361  
 
 4362  0
             root_1 = (CommonTree)adaptor.becomeRoot(BINDINGS109_tree, root_1);
 4363  
 
 4364  
 
 4365  0
             if ( input.LA(1)==Token.DOWN ) {
 4366  0
                 match(input, Token.DOWN, null); 
 4367  
                 // com\\googlecode\\sparkleg\\SparqlT.g:134:18: ( var )*
 4368  
                 loop44:
 4369  
                 do {
 4370  0
                     int alt44=2;
 4371  0
                     switch ( input.LA(1) ) {
 4372  
                     case VAR1:
 4373  
                     case VAR2:
 4374  
                         {
 4375  0
                         alt44=1;
 4376  
                         }
 4377  
                         break;
 4378  
 
 4379  
                     }
 4380  
 
 4381  0
                     switch (alt44) {
 4382  
                         case 1 :
 4383  
                             // com\\googlecode\\sparkleg\\SparqlT.g:134:18: var
 4384  
                             {
 4385  0
                             _last = (CommonTree)input.LT(1);
 4386  0
                             pushFollow(FOLLOW_var_in_bindingsClause806);
 4387  0
                             var110=var();
 4388  
 
 4389  0
                             state._fsp--;
 4390  
 
 4391  0
                             adaptor.addChild(root_1, var110.getTree());
 4392  
 
 4393  
 
 4394  
                             }
 4395  0
                             break;
 4396  
 
 4397  
                         default :
 4398  0
                             break loop44;
 4399  
                     }
 4400  0
                 } while (true);
 4401  
 
 4402  
 
 4403  
                 // com\\googlecode\\sparkleg\\SparqlT.g:134:23: ( bindingValueList )*
 4404  
                 loop45:
 4405  
                 do {
 4406  0
                     int alt45=2;
 4407  0
                     switch ( input.LA(1) ) {
 4408  
                     case BINDING_VALUE:
 4409  
                         {
 4410  0
                         alt45=1;
 4411  
                         }
 4412  
                         break;
 4413  
 
 4414  
                     }
 4415  
 
 4416  0
                     switch (alt45) {
 4417  
                         case 1 :
 4418  
                             // com\\googlecode\\sparkleg\\SparqlT.g:134:23: bindingValueList
 4419  
                             {
 4420  0
                             _last = (CommonTree)input.LT(1);
 4421  0
                             pushFollow(FOLLOW_bindingValueList_in_bindingsClause809);
 4422  0
                             bindingValueList111=bindingValueList();
 4423  
 
 4424  0
                             state._fsp--;
 4425  
 
 4426  0
                             adaptor.addChild(root_1, bindingValueList111.getTree());
 4427  
 
 4428  
 
 4429  
                             }
 4430  0
                             break;
 4431  
 
 4432  
                         default :
 4433  0
                             break loop45;
 4434  
                     }
 4435  0
                 } while (true);
 4436  
 
 4437  
 
 4438  0
                 match(input, Token.UP, null); 
 4439  
             }
 4440  0
             adaptor.addChild(root_0, root_1);
 4441  0
             _last = _save_last_1;
 4442  
             }
 4443  
 
 4444  
 
 4445  
             }
 4446  
 
 4447  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 4448  
 
 4449  
         }
 4450  0
         catch (RecognitionException re) {
 4451  0
             reportError(re);
 4452  0
             recover(input,re);
 4453  
         }
 4454  
 
 4455  0
         finally {
 4456  
                 // do for sure before leaving
 4457  0
         }
 4458  0
         return retval;
 4459  
     }
 4460  
     // $ANTLR end "bindingsClause"
 4461  
 
 4462  
 
 4463  0
     public static class bindingValueList_return extends TreeRuleReturnScope {
 4464  
         CommonTree tree;
 4465  0
         public Object getTree() { return tree; }
 4466  
     };
 4467  
 
 4468  
 
 4469  
     // $ANTLR start "bindingValueList"
 4470  
     // com\\googlecode\\sparkleg\\SparqlT.g:137:1: bindingValueList : ^( BINDING_VALUE ( bindingValue )* ) ;
 4471  
     public final SparqlT.bindingValueList_return bindingValueList() throws RecognitionException {
 4472  0
         SparqlT.bindingValueList_return retval = new SparqlT.bindingValueList_return();
 4473  0
         retval.start = input.LT(1);
 4474  
 
 4475  
 
 4476  0
         CommonTree root_0 = null;
 4477  
 
 4478  0
         CommonTree _first_0 = null;
 4479  0
         CommonTree _last = null;
 4480  
 
 4481  0
         CommonTree BINDING_VALUE112=null;
 4482  0
         SparqlT.bindingValue_return bindingValue113 =null;
 4483  
 
 4484  
 
 4485  0
         CommonTree BINDING_VALUE112_tree=null;
 4486  
 
 4487  
         try {
 4488  
             // com\\googlecode\\sparkleg\\SparqlT.g:138:5: ( ^( BINDING_VALUE ( bindingValue )* ) )
 4489  
             // com\\googlecode\\sparkleg\\SparqlT.g:138:7: ^( BINDING_VALUE ( bindingValue )* )
 4490  
             {
 4491  0
             root_0 = (CommonTree)adaptor.nil();
 4492  
 
 4493  
 
 4494  0
             _last = (CommonTree)input.LT(1);
 4495  
             {
 4496  0
             CommonTree _save_last_1 = _last;
 4497  0
             CommonTree _first_1 = null;
 4498  0
             CommonTree root_1 = (CommonTree)adaptor.nil();
 4499  0
             _last = (CommonTree)input.LT(1);
 4500  0
             BINDING_VALUE112=(CommonTree)match(input,BINDING_VALUE,FOLLOW_BINDING_VALUE_in_bindingValueList833); 
 4501  0
             BINDING_VALUE112_tree = (CommonTree)adaptor.dupNode(BINDING_VALUE112);
 4502  
 
 4503  
 
 4504  0
             root_1 = (CommonTree)adaptor.becomeRoot(BINDING_VALUE112_tree, root_1);
 4505  
 
 4506  
 
 4507  0
             if ( input.LA(1)==Token.DOWN ) {
 4508  0
                 match(input, Token.DOWN, null); 
 4509  
                 // com\\googlecode\\sparkleg\\SparqlT.g:138:23: ( bindingValue )*
 4510  
                 loop46:
 4511  
                 do {
 4512  0
                     int alt46=2;
 4513  0
                     switch ( input.LA(1) ) {
 4514  
                     case DECIMAL:
 4515  
                     case DECIMAL_NEGATIVE:
 4516  
                     case DECIMAL_POSITIVE:
 4517  
                     case DOUBLE:
 4518  
                     case DOUBLE_NEGATIVE:
 4519  
                     case DOUBLE_POSITIVE:
 4520  
                     case FALSE:
 4521  
                     case INTEGER:
 4522  
                     case INTEGER_NEGATIVE:
 4523  
                     case INTEGER_POSITIVE:
 4524  
                     case IRI_REF:
 4525  
                     case PNAME_LN:
 4526  
                     case PNAME_NS:
 4527  
                     case STRING_LITERAL1:
 4528  
                     case STRING_LITERAL2:
 4529  
                     case STRING_LITERAL_LONG1:
 4530  
                     case STRING_LITERAL_LONG2:
 4531  
                     case TRUE:
 4532  
                     case UNDEF:
 4533  
                         {
 4534  0
                         alt46=1;
 4535  
                         }
 4536  
                         break;
 4537  
 
 4538  
                     }
 4539  
 
 4540  0
                     switch (alt46) {
 4541  
                         case 1 :
 4542  
                             // com\\googlecode\\sparkleg\\SparqlT.g:138:23: bindingValue
 4543  
                             {
 4544  0
                             _last = (CommonTree)input.LT(1);
 4545  0
                             pushFollow(FOLLOW_bindingValue_in_bindingValueList835);
 4546  0
                             bindingValue113=bindingValue();
 4547  
 
 4548  0
                             state._fsp--;
 4549  
 
 4550  0
                             adaptor.addChild(root_1, bindingValue113.getTree());
 4551  
 
 4552  
 
 4553  
                             }
 4554  0
                             break;
 4555  
 
 4556  
                         default :
 4557  0
                             break loop46;
 4558  
                     }
 4559  0
                 } while (true);
 4560  
 
 4561  
 
 4562  0
                 match(input, Token.UP, null); 
 4563  
             }
 4564  0
             adaptor.addChild(root_0, root_1);
 4565  0
             _last = _save_last_1;
 4566  
             }
 4567  
 
 4568  
 
 4569  
             }
 4570  
 
 4571  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 4572  
 
 4573  
         }
 4574  0
         catch (RecognitionException re) {
 4575  0
             reportError(re);
 4576  0
             recover(input,re);
 4577  
         }
 4578  
 
 4579  0
         finally {
 4580  
                 // do for sure before leaving
 4581  0
         }
 4582  0
         return retval;
 4583  
     }
 4584  
     // $ANTLR end "bindingValueList"
 4585  
 
 4586  
 
 4587  0
     public static class bindingValue_return extends TreeRuleReturnScope {
 4588  
         CommonTree tree;
 4589  0
         public Object getTree() { return tree; }
 4590  
     };
 4591  
 
 4592  
 
 4593  
     // $ANTLR start "bindingValue"
 4594  
     // com\\googlecode\\sparkleg\\SparqlT.g:141:1: bindingValue : ( iriRef | rdfLiteral | numericLiteral | booleanLiteral | UNDEF );
 4595  
     public final SparqlT.bindingValue_return bindingValue() throws RecognitionException {
 4596  0
         SparqlT.bindingValue_return retval = new SparqlT.bindingValue_return();
 4597  0
         retval.start = input.LT(1);
 4598  
 
 4599  
 
 4600  0
         CommonTree root_0 = null;
 4601  
 
 4602  0
         CommonTree _first_0 = null;
 4603  0
         CommonTree _last = null;
 4604  
 
 4605  0
         CommonTree UNDEF118=null;
 4606  0
         SparqlT.iriRef_return iriRef114 =null;
 4607  
 
 4608  0
         SparqlT.rdfLiteral_return rdfLiteral115 =null;
 4609  
 
 4610  0
         SparqlT.numericLiteral_return numericLiteral116 =null;
 4611  
 
 4612  0
         SparqlT.booleanLiteral_return booleanLiteral117 =null;
 4613  
 
 4614  
 
 4615  0
         CommonTree UNDEF118_tree=null;
 4616  
 
 4617  
         try {
 4618  
             // com\\googlecode\\sparkleg\\SparqlT.g:142:5: ( iriRef | rdfLiteral | numericLiteral | booleanLiteral | UNDEF )
 4619  0
             int alt47=5;
 4620  0
             switch ( input.LA(1) ) {
 4621  
             case IRI_REF:
 4622  
             case PNAME_LN:
 4623  
             case PNAME_NS:
 4624  
                 {
 4625  0
                 alt47=1;
 4626  
                 }
 4627  0
                 break;
 4628  
             case STRING_LITERAL1:
 4629  
             case STRING_LITERAL2:
 4630  
             case STRING_LITERAL_LONG1:
 4631  
             case STRING_LITERAL_LONG2:
 4632  
                 {
 4633  0
                 alt47=2;
 4634  
                 }
 4635  0
                 break;
 4636  
             case DECIMAL:
 4637  
             case DECIMAL_NEGATIVE:
 4638  
             case DECIMAL_POSITIVE:
 4639  
             case DOUBLE:
 4640  
             case DOUBLE_NEGATIVE:
 4641  
             case DOUBLE_POSITIVE:
 4642  
             case INTEGER:
 4643  
             case INTEGER_NEGATIVE:
 4644  
             case INTEGER_POSITIVE:
 4645  
                 {
 4646  0
                 alt47=3;
 4647  
                 }
 4648  0
                 break;
 4649  
             case FALSE:
 4650  
             case TRUE:
 4651  
                 {
 4652  0
                 alt47=4;
 4653  
                 }
 4654  0
                 break;
 4655  
             case UNDEF:
 4656  
                 {
 4657  0
                 alt47=5;
 4658  
                 }
 4659  0
                 break;
 4660  
             default:
 4661  0
                 NoViableAltException nvae =
 4662  
                     new NoViableAltException("", 47, 0, input);
 4663  
 
 4664  0
                 throw nvae;
 4665  
 
 4666  
             }
 4667  
 
 4668  0
             switch (alt47) {
 4669  
                 case 1 :
 4670  
                     // com\\googlecode\\sparkleg\\SparqlT.g:142:7: iriRef
 4671  
                     {
 4672  0
                     root_0 = (CommonTree)adaptor.nil();
 4673  
 
 4674  
 
 4675  0
                     _last = (CommonTree)input.LT(1);
 4676  0
                     pushFollow(FOLLOW_iriRef_in_bindingValue859);
 4677  0
                     iriRef114=iriRef();
 4678  
 
 4679  0
                     state._fsp--;
 4680  
 
 4681  0
                     adaptor.addChild(root_0, iriRef114.getTree());
 4682  
 
 4683  
 
 4684  
                     }
 4685  0
                     break;
 4686  
                 case 2 :
 4687  
                     // com\\googlecode\\sparkleg\\SparqlT.g:142:16: rdfLiteral
 4688  
                     {
 4689  0
                     root_0 = (CommonTree)adaptor.nil();
 4690  
 
 4691  
 
 4692  0
                     _last = (CommonTree)input.LT(1);
 4693  0
                     pushFollow(FOLLOW_rdfLiteral_in_bindingValue863);
 4694  0
                     rdfLiteral115=rdfLiteral();
 4695  
 
 4696  0
                     state._fsp--;
 4697  
 
 4698  0
                     adaptor.addChild(root_0, rdfLiteral115.getTree());
 4699  
 
 4700  
 
 4701  
                     }
 4702  0
                     break;
 4703  
                 case 3 :
 4704  
                     // com\\googlecode\\sparkleg\\SparqlT.g:142:29: numericLiteral
 4705  
                     {
 4706  0
                     root_0 = (CommonTree)adaptor.nil();
 4707  
 
 4708  
 
 4709  0
                     _last = (CommonTree)input.LT(1);
 4710  0
                     pushFollow(FOLLOW_numericLiteral_in_bindingValue867);
 4711  0
                     numericLiteral116=numericLiteral();
 4712  
 
 4713  0
                     state._fsp--;
 4714  
 
 4715  0
                     adaptor.addChild(root_0, numericLiteral116.getTree());
 4716  
 
 4717  
 
 4718  
                     }
 4719  0
                     break;
 4720  
                 case 4 :
 4721  
                     // com\\googlecode\\sparkleg\\SparqlT.g:142:46: booleanLiteral
 4722  
                     {
 4723  0
                     root_0 = (CommonTree)adaptor.nil();
 4724  
 
 4725  
 
 4726  0
                     _last = (CommonTree)input.LT(1);
 4727  0
                     pushFollow(FOLLOW_booleanLiteral_in_bindingValue871);
 4728  0
                     booleanLiteral117=booleanLiteral();
 4729  
 
 4730  0
                     state._fsp--;
 4731  
 
 4732  0
                     adaptor.addChild(root_0, booleanLiteral117.getTree());
 4733  
 
 4734  
 
 4735  
                     }
 4736  0
                     break;
 4737  
                 case 5 :
 4738  
                     // com\\googlecode\\sparkleg\\SparqlT.g:142:63: UNDEF
 4739  
                     {
 4740  0
                     root_0 = (CommonTree)adaptor.nil();
 4741  
 
 4742  
 
 4743  0
                     _last = (CommonTree)input.LT(1);
 4744  0
                     UNDEF118=(CommonTree)match(input,UNDEF,FOLLOW_UNDEF_in_bindingValue875); 
 4745  0
                     UNDEF118_tree = (CommonTree)adaptor.dupNode(UNDEF118);
 4746  
 
 4747  
 
 4748  0
                     adaptor.addChild(root_0, UNDEF118_tree);
 4749  
 
 4750  
 
 4751  
                     }
 4752  
                     break;
 4753  
 
 4754  
             }
 4755  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 4756  
 
 4757  
         }
 4758  0
         catch (RecognitionException re) {
 4759  0
             reportError(re);
 4760  0
             recover(input,re);
 4761  
         }
 4762  
 
 4763  0
         finally {
 4764  
                 // do for sure before leaving
 4765  0
         }
 4766  0
         return retval;
 4767  
     }
 4768  
     // $ANTLR end "bindingValue"
 4769  
 
 4770  
 
 4771  0
     public static class update_return extends TreeRuleReturnScope {
 4772  
         CommonTree tree;
 4773  0
         public Object getTree() { return tree; }
 4774  
     };
 4775  
 
 4776  
 
 4777  
     // $ANTLR start "update"
 4778  
     // com\\googlecode\\sparkleg\\SparqlT.g:145:1: update : prologue ( load )* ( clear )* ( drop )* ( add )* ( move )* ( copy )* ( create )* ( insert )* ( delete )* ( modify )* ;
 4779  
     public final SparqlT.update_return update() throws RecognitionException {
 4780  0
         SparqlT.update_return retval = new SparqlT.update_return();
 4781  0
         retval.start = input.LT(1);
 4782  
 
 4783  
 
 4784  0
         CommonTree root_0 = null;
 4785  
 
 4786  0
         CommonTree _first_0 = null;
 4787  0
         CommonTree _last = null;
 4788  
 
 4789  0
         SparqlT.prologue_return prologue119 =null;
 4790  
 
 4791  0
         SparqlT.load_return load120 =null;
 4792  
 
 4793  0
         SparqlT.clear_return clear121 =null;
 4794  
 
 4795  0
         SparqlT.drop_return drop122 =null;
 4796  
 
 4797  0
         SparqlT.add_return add123 =null;
 4798  
 
 4799  0
         SparqlT.move_return move124 =null;
 4800  
 
 4801  0
         SparqlT.copy_return copy125 =null;
 4802  
 
 4803  0
         SparqlT.create_return create126 =null;
 4804  
 
 4805  0
         SparqlT.insert_return insert127 =null;
 4806  
 
 4807  0
         SparqlT.delete_return delete128 =null;
 4808  
 
 4809  0
         SparqlT.modify_return modify129 =null;
 4810  
 
 4811  
 
 4812  
 
 4813  
         try {
 4814  
             // com\\googlecode\\sparkleg\\SparqlT.g:146:5: ( prologue ( load )* ( clear )* ( drop )* ( add )* ( move )* ( copy )* ( create )* ( insert )* ( delete )* ( modify )* )
 4815  
             // com\\googlecode\\sparkleg\\SparqlT.g:146:7: prologue ( load )* ( clear )* ( drop )* ( add )* ( move )* ( copy )* ( create )* ( insert )* ( delete )* ( modify )*
 4816  
             {
 4817  0
             root_0 = (CommonTree)adaptor.nil();
 4818  
 
 4819  
 
 4820  0
             _last = (CommonTree)input.LT(1);
 4821  0
             pushFollow(FOLLOW_prologue_in_update896);
 4822  0
             prologue119=prologue();
 4823  
 
 4824  0
             state._fsp--;
 4825  
 
 4826  0
             adaptor.addChild(root_0, prologue119.getTree());
 4827  
 
 4828  
 
 4829  
             // com\\googlecode\\sparkleg\\SparqlT.g:146:16: ( load )*
 4830  
             loop48:
 4831  
             do {
 4832  0
                 int alt48=2;
 4833  0
                 switch ( input.LA(1) ) {
 4834  
                 case LOAD:
 4835  
                     {
 4836  0
                     alt48=1;
 4837  
                     }
 4838  
                     break;
 4839  
 
 4840  
                 }
 4841  
 
 4842  0
                 switch (alt48) {
 4843  
                     case 1 :
 4844  
                         // com\\googlecode\\sparkleg\\SparqlT.g:146:16: load
 4845  
                         {
 4846  0
                         _last = (CommonTree)input.LT(1);
 4847  0
                         pushFollow(FOLLOW_load_in_update898);
 4848  0
                         load120=load();
 4849  
 
 4850  0
                         state._fsp--;
 4851  
 
 4852  0
                         adaptor.addChild(root_0, load120.getTree());
 4853  
 
 4854  
 
 4855  
                         }
 4856  0
                         break;
 4857  
 
 4858  
                     default :
 4859  0
                         break loop48;
 4860  
                 }
 4861  0
             } while (true);
 4862  
 
 4863  
 
 4864  
             // com\\googlecode\\sparkleg\\SparqlT.g:146:22: ( clear )*
 4865  
             loop49:
 4866  
             do {
 4867  0
                 int alt49=2;
 4868  0
                 switch ( input.LA(1) ) {
 4869  
                 case CLEAR:
 4870  
                     {
 4871  0
                     alt49=1;
 4872  
                     }
 4873  
                     break;
 4874  
 
 4875  
                 }
 4876  
 
 4877  0
                 switch (alt49) {
 4878  
                     case 1 :
 4879  
                         // com\\googlecode\\sparkleg\\SparqlT.g:146:22: clear
 4880  
                         {
 4881  0
                         _last = (CommonTree)input.LT(1);
 4882  0
                         pushFollow(FOLLOW_clear_in_update901);
 4883  0
                         clear121=clear();
 4884  
 
 4885  0
                         state._fsp--;
 4886  
 
 4887  0
                         adaptor.addChild(root_0, clear121.getTree());
 4888  
 
 4889  
 
 4890  
                         }
 4891  0
                         break;
 4892  
 
 4893  
                     default :
 4894  0
                         break loop49;
 4895  
                 }
 4896  0
             } while (true);
 4897  
 
 4898  
 
 4899  
             // com\\googlecode\\sparkleg\\SparqlT.g:146:29: ( drop )*
 4900  
             loop50:
 4901  
             do {
 4902  0
                 int alt50=2;
 4903  0
                 switch ( input.LA(1) ) {
 4904  
                 case DROP:
 4905  
                     {
 4906  0
                     alt50=1;
 4907  
                     }
 4908  
                     break;
 4909  
 
 4910  
                 }
 4911  
 
 4912  0
                 switch (alt50) {
 4913  
                     case 1 :
 4914  
                         // com\\googlecode\\sparkleg\\SparqlT.g:146:29: drop
 4915  
                         {
 4916  0
                         _last = (CommonTree)input.LT(1);
 4917  0
                         pushFollow(FOLLOW_drop_in_update904);
 4918  0
                         drop122=drop();
 4919  
 
 4920  0
                         state._fsp--;
 4921  
 
 4922  0
                         adaptor.addChild(root_0, drop122.getTree());
 4923  
 
 4924  
 
 4925  
                         }
 4926  0
                         break;
 4927  
 
 4928  
                     default :
 4929  0
                         break loop50;
 4930  
                 }
 4931  0
             } while (true);
 4932  
 
 4933  
 
 4934  
             // com\\googlecode\\sparkleg\\SparqlT.g:146:35: ( add )*
 4935  
             loop51:
 4936  
             do {
 4937  0
                 int alt51=2;
 4938  0
                 switch ( input.LA(1) ) {
 4939  
                 case ADD:
 4940  
                     {
 4941  0
                     alt51=1;
 4942  
                     }
 4943  
                     break;
 4944  
 
 4945  
                 }
 4946  
 
 4947  0
                 switch (alt51) {
 4948  
                     case 1 :
 4949  
                         // com\\googlecode\\sparkleg\\SparqlT.g:146:35: add
 4950  
                         {
 4951  0
                         _last = (CommonTree)input.LT(1);
 4952  0
                         pushFollow(FOLLOW_add_in_update907);
 4953  0
                         add123=add();
 4954  
 
 4955  0
                         state._fsp--;
 4956  
 
 4957  0
                         adaptor.addChild(root_0, add123.getTree());
 4958  
 
 4959  
 
 4960  
                         }
 4961  0
                         break;
 4962  
 
 4963  
                     default :
 4964  0
                         break loop51;
 4965  
                 }
 4966  0
             } while (true);
 4967  
 
 4968  
 
 4969  
             // com\\googlecode\\sparkleg\\SparqlT.g:146:40: ( move )*
 4970  
             loop52:
 4971  
             do {
 4972  0
                 int alt52=2;
 4973  0
                 switch ( input.LA(1) ) {
 4974  
                 case MOVE:
 4975  
                     {
 4976  0
                     alt52=1;
 4977  
                     }
 4978  
                     break;
 4979  
 
 4980  
                 }
 4981  
 
 4982  0
                 switch (alt52) {
 4983  
                     case 1 :
 4984  
                         // com\\googlecode\\sparkleg\\SparqlT.g:146:40: move
 4985  
                         {
 4986  0
                         _last = (CommonTree)input.LT(1);
 4987  0
                         pushFollow(FOLLOW_move_in_update910);
 4988  0
                         move124=move();
 4989  
 
 4990  0
                         state._fsp--;
 4991  
 
 4992  0
                         adaptor.addChild(root_0, move124.getTree());
 4993  
 
 4994  
 
 4995  
                         }
 4996  0
                         break;
 4997  
 
 4998  
                     default :
 4999  0
                         break loop52;
 5000  
                 }
 5001  0
             } while (true);
 5002  
 
 5003  
 
 5004  
             // com\\googlecode\\sparkleg\\SparqlT.g:146:46: ( copy )*
 5005  
             loop53:
 5006  
             do {
 5007  0
                 int alt53=2;
 5008  0
                 switch ( input.LA(1) ) {
 5009  
                 case COPY:
 5010  
                     {
 5011  0
                     alt53=1;
 5012  
                     }
 5013  
                     break;
 5014  
 
 5015  
                 }
 5016  
 
 5017  0
                 switch (alt53) {
 5018  
                     case 1 :
 5019  
                         // com\\googlecode\\sparkleg\\SparqlT.g:146:46: copy
 5020  
                         {
 5021  0
                         _last = (CommonTree)input.LT(1);
 5022  0
                         pushFollow(FOLLOW_copy_in_update913);
 5023  0
                         copy125=copy();
 5024  
 
 5025  0
                         state._fsp--;
 5026  
 
 5027  0
                         adaptor.addChild(root_0, copy125.getTree());
 5028  
 
 5029  
 
 5030  
                         }
 5031  0
                         break;
 5032  
 
 5033  
                     default :
 5034  0
                         break loop53;
 5035  
                 }
 5036  0
             } while (true);
 5037  
 
 5038  
 
 5039  
             // com\\googlecode\\sparkleg\\SparqlT.g:146:52: ( create )*
 5040  
             loop54:
 5041  
             do {
 5042  0
                 int alt54=2;
 5043  0
                 switch ( input.LA(1) ) {
 5044  
                 case CREATE:
 5045  
                     {
 5046  0
                     alt54=1;
 5047  
                     }
 5048  
                     break;
 5049  
 
 5050  
                 }
 5051  
 
 5052  0
                 switch (alt54) {
 5053  
                     case 1 :
 5054  
                         // com\\googlecode\\sparkleg\\SparqlT.g:146:52: create
 5055  
                         {
 5056  0
                         _last = (CommonTree)input.LT(1);
 5057  0
                         pushFollow(FOLLOW_create_in_update916);
 5058  0
                         create126=create();
 5059  
 
 5060  0
                         state._fsp--;
 5061  
 
 5062  0
                         adaptor.addChild(root_0, create126.getTree());
 5063  
 
 5064  
 
 5065  
                         }
 5066  0
                         break;
 5067  
 
 5068  
                     default :
 5069  0
                         break loop54;
 5070  
                 }
 5071  0
             } while (true);
 5072  
 
 5073  
 
 5074  
             // com\\googlecode\\sparkleg\\SparqlT.g:146:60: ( insert )*
 5075  
             loop55:
 5076  
             do {
 5077  0
                 int alt55=2;
 5078  0
                 switch ( input.LA(1) ) {
 5079  
                 case INSERT:
 5080  
                     {
 5081  0
                     alt55=1;
 5082  
                     }
 5083  
                     break;
 5084  
 
 5085  
                 }
 5086  
 
 5087  0
                 switch (alt55) {
 5088  
                     case 1 :
 5089  
                         // com\\googlecode\\sparkleg\\SparqlT.g:146:60: insert
 5090  
                         {
 5091  0
                         _last = (CommonTree)input.LT(1);
 5092  0
                         pushFollow(FOLLOW_insert_in_update919);
 5093  0
                         insert127=insert();
 5094  
 
 5095  0
                         state._fsp--;
 5096  
 
 5097  0
                         adaptor.addChild(root_0, insert127.getTree());
 5098  
 
 5099  
 
 5100  
                         }
 5101  0
                         break;
 5102  
 
 5103  
                     default :
 5104  0
                         break loop55;
 5105  
                 }
 5106  0
             } while (true);
 5107  
 
 5108  
 
 5109  
             // com\\googlecode\\sparkleg\\SparqlT.g:146:68: ( delete )*
 5110  
             loop56:
 5111  
             do {
 5112  0
                 int alt56=2;
 5113  0
                 switch ( input.LA(1) ) {
 5114  
                 case DELETE:
 5115  
                     {
 5116  0
                     alt56=1;
 5117  
                     }
 5118  
                     break;
 5119  
 
 5120  
                 }
 5121  
 
 5122  0
                 switch (alt56) {
 5123  
                     case 1 :
 5124  
                         // com\\googlecode\\sparkleg\\SparqlT.g:146:68: delete
 5125  
                         {
 5126  0
                         _last = (CommonTree)input.LT(1);
 5127  0
                         pushFollow(FOLLOW_delete_in_update922);
 5128  0
                         delete128=delete();
 5129  
 
 5130  0
                         state._fsp--;
 5131  
 
 5132  0
                         adaptor.addChild(root_0, delete128.getTree());
 5133  
 
 5134  
 
 5135  
                         }
 5136  0
                         break;
 5137  
 
 5138  
                     default :
 5139  0
                         break loop56;
 5140  
                 }
 5141  0
             } while (true);
 5142  
 
 5143  
 
 5144  
             // com\\googlecode\\sparkleg\\SparqlT.g:146:76: ( modify )*
 5145  
             loop57:
 5146  
             do {
 5147  0
                 int alt57=2;
 5148  0
                 switch ( input.LA(1) ) {
 5149  
                 case MODIFY:
 5150  
                     {
 5151  0
                     alt57=1;
 5152  
                     }
 5153  
                     break;
 5154  
 
 5155  
                 }
 5156  
 
 5157  0
                 switch (alt57) {
 5158  
                     case 1 :
 5159  
                         // com\\googlecode\\sparkleg\\SparqlT.g:146:76: modify
 5160  
                         {
 5161  0
                         _last = (CommonTree)input.LT(1);
 5162  0
                         pushFollow(FOLLOW_modify_in_update925);
 5163  0
                         modify129=modify();
 5164  
 
 5165  0
                         state._fsp--;
 5166  
 
 5167  0
                         adaptor.addChild(root_0, modify129.getTree());
 5168  
 
 5169  
 
 5170  
                         }
 5171  0
                         break;
 5172  
 
 5173  
                     default :
 5174  0
                         break loop57;
 5175  
                 }
 5176  0
             } while (true);
 5177  
 
 5178  
 
 5179  
             }
 5180  
 
 5181  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 5182  
 
 5183  
         }
 5184  0
         catch (RecognitionException re) {
 5185  0
             reportError(re);
 5186  0
             recover(input,re);
 5187  
         }
 5188  
 
 5189  0
         finally {
 5190  
                 // do for sure before leaving
 5191  0
         }
 5192  0
         return retval;
 5193  
     }
 5194  
     // $ANTLR end "update"
 5195  
 
 5196  
 
 5197  0
     public static class load_return extends TreeRuleReturnScope {
 5198  
         CommonTree tree;
 5199  0
         public Object getTree() { return tree; }
 5200  
     };
 5201  
 
 5202  
 
 5203  
     // $ANTLR start "load"
 5204  
     // com\\googlecode\\sparkleg\\SparqlT.g:149:1: load : ^( LOAD ( SILENT )* iriRef ( graphRef )? ) ;
 5205  
     public final SparqlT.load_return load() throws RecognitionException {
 5206  0
         SparqlT.load_return retval = new SparqlT.load_return();
 5207  0
         retval.start = input.LT(1);
 5208  
 
 5209  
 
 5210  0
         CommonTree root_0 = null;
 5211  
 
 5212  0
         CommonTree _first_0 = null;
 5213  0
         CommonTree _last = null;
 5214  
 
 5215  0
         CommonTree LOAD130=null;
 5216  0
         CommonTree SILENT131=null;
 5217  0
         SparqlT.iriRef_return iriRef132 =null;
 5218  
 
 5219  0
         SparqlT.graphRef_return graphRef133 =null;
 5220  
 
 5221  
 
 5222  0
         CommonTree LOAD130_tree=null;
 5223  0
         CommonTree SILENT131_tree=null;
 5224  
 
 5225  
         try {
 5226  
             // com\\googlecode\\sparkleg\\SparqlT.g:150:5: ( ^( LOAD ( SILENT )* iriRef ( graphRef )? ) )
 5227  
             // com\\googlecode\\sparkleg\\SparqlT.g:150:7: ^( LOAD ( SILENT )* iriRef ( graphRef )? )
 5228  
             {
 5229  0
             root_0 = (CommonTree)adaptor.nil();
 5230  
 
 5231  
 
 5232  0
             _last = (CommonTree)input.LT(1);
 5233  
             {
 5234  0
             CommonTree _save_last_1 = _last;
 5235  0
             CommonTree _first_1 = null;
 5236  0
             CommonTree root_1 = (CommonTree)adaptor.nil();
 5237  0
             _last = (CommonTree)input.LT(1);
 5238  0
             LOAD130=(CommonTree)match(input,LOAD,FOLLOW_LOAD_in_load955); 
 5239  0
             LOAD130_tree = (CommonTree)adaptor.dupNode(LOAD130);
 5240  
 
 5241  
 
 5242  0
             root_1 = (CommonTree)adaptor.becomeRoot(LOAD130_tree, root_1);
 5243  
 
 5244  
 
 5245  0
             match(input, Token.DOWN, null); 
 5246  
             // com\\googlecode\\sparkleg\\SparqlT.g:150:14: ( SILENT )*
 5247  
             loop58:
 5248  
             do {
 5249  0
                 int alt58=2;
 5250  0
                 switch ( input.LA(1) ) {
 5251  
                 case SILENT:
 5252  
                     {
 5253  0
                     alt58=1;
 5254  
                     }
 5255  
                     break;
 5256  
 
 5257  
                 }
 5258  
 
 5259  0
                 switch (alt58) {
 5260  
                     case 1 :
 5261  
                         // com\\googlecode\\sparkleg\\SparqlT.g:150:14: SILENT
 5262  
                         {
 5263  0
                         _last = (CommonTree)input.LT(1);
 5264  0
                         SILENT131=(CommonTree)match(input,SILENT,FOLLOW_SILENT_in_load957); 
 5265  0
                         SILENT131_tree = (CommonTree)adaptor.dupNode(SILENT131);
 5266  
 
 5267  
 
 5268  0
                         adaptor.addChild(root_1, SILENT131_tree);
 5269  
 
 5270  
 
 5271  
                         }
 5272  0
                         break;
 5273  
 
 5274  
                     default :
 5275  0
                         break loop58;
 5276  
                 }
 5277  0
             } while (true);
 5278  
 
 5279  
 
 5280  0
             _last = (CommonTree)input.LT(1);
 5281  0
             pushFollow(FOLLOW_iriRef_in_load960);
 5282  0
             iriRef132=iriRef();
 5283  
 
 5284  0
             state._fsp--;
 5285  
 
 5286  0
             adaptor.addChild(root_1, iriRef132.getTree());
 5287  
 
 5288  
 
 5289  
             // com\\googlecode\\sparkleg\\SparqlT.g:150:29: ( graphRef )?
 5290  0
             int alt59=2;
 5291  0
             switch ( input.LA(1) ) {
 5292  
                 case GRAPH:
 5293  
                     {
 5294  0
                     alt59=1;
 5295  
                     }
 5296  
                     break;
 5297  
             }
 5298  
 
 5299  0
             switch (alt59) {
 5300  
                 case 1 :
 5301  
                     // com\\googlecode\\sparkleg\\SparqlT.g:150:29: graphRef
 5302  
                     {
 5303  0
                     _last = (CommonTree)input.LT(1);
 5304  0
                     pushFollow(FOLLOW_graphRef_in_load962);
 5305  0
                     graphRef133=graphRef();
 5306  
 
 5307  0
                     state._fsp--;
 5308  
 
 5309  0
                     adaptor.addChild(root_1, graphRef133.getTree());
 5310  
 
 5311  
 
 5312  
                     }
 5313  
                     break;
 5314  
 
 5315  
             }
 5316  
 
 5317  
 
 5318  0
             match(input, Token.UP, null); 
 5319  0
             adaptor.addChild(root_0, root_1);
 5320  0
             _last = _save_last_1;
 5321  
             }
 5322  
 
 5323  
 
 5324  
             }
 5325  
 
 5326  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 5327  
 
 5328  
         }
 5329  0
         catch (RecognitionException re) {
 5330  0
             reportError(re);
 5331  0
             recover(input,re);
 5332  
         }
 5333  
 
 5334  0
         finally {
 5335  
                 // do for sure before leaving
 5336  0
         }
 5337  0
         return retval;
 5338  
     }
 5339  
     // $ANTLR end "load"
 5340  
 
 5341  
 
 5342  0
     public static class clear_return extends TreeRuleReturnScope {
 5343  
         CommonTree tree;
 5344  0
         public Object getTree() { return tree; }
 5345  
     };
 5346  
 
 5347  
 
 5348  
     // $ANTLR start "clear"
 5349  
     // com\\googlecode\\sparkleg\\SparqlT.g:153:1: clear : ^( CLEAR ( SILENT )* graphRefAll ) ;
 5350  
     public final SparqlT.clear_return clear() throws RecognitionException {
 5351  0
         SparqlT.clear_return retval = new SparqlT.clear_return();
 5352  0
         retval.start = input.LT(1);
 5353  
 
 5354  
 
 5355  0
         CommonTree root_0 = null;
 5356  
 
 5357  0
         CommonTree _first_0 = null;
 5358  0
         CommonTree _last = null;
 5359  
 
 5360  0
         CommonTree CLEAR134=null;
 5361  0
         CommonTree SILENT135=null;
 5362  0
         SparqlT.graphRefAll_return graphRefAll136 =null;
 5363  
 
 5364  
 
 5365  0
         CommonTree CLEAR134_tree=null;
 5366  0
         CommonTree SILENT135_tree=null;
 5367  
 
 5368  
         try {
 5369  
             // com\\googlecode\\sparkleg\\SparqlT.g:154:5: ( ^( CLEAR ( SILENT )* graphRefAll ) )
 5370  
             // com\\googlecode\\sparkleg\\SparqlT.g:154:7: ^( CLEAR ( SILENT )* graphRefAll )
 5371  
             {
 5372  0
             root_0 = (CommonTree)adaptor.nil();
 5373  
 
 5374  
 
 5375  0
             _last = (CommonTree)input.LT(1);
 5376  
             {
 5377  0
             CommonTree _save_last_1 = _last;
 5378  0
             CommonTree _first_1 = null;
 5379  0
             CommonTree root_1 = (CommonTree)adaptor.nil();
 5380  0
             _last = (CommonTree)input.LT(1);
 5381  0
             CLEAR134=(CommonTree)match(input,CLEAR,FOLLOW_CLEAR_in_clear986); 
 5382  0
             CLEAR134_tree = (CommonTree)adaptor.dupNode(CLEAR134);
 5383  
 
 5384  
 
 5385  0
             root_1 = (CommonTree)adaptor.becomeRoot(CLEAR134_tree, root_1);
 5386  
 
 5387  
 
 5388  0
             match(input, Token.DOWN, null); 
 5389  
             // com\\googlecode\\sparkleg\\SparqlT.g:154:15: ( SILENT )*
 5390  
             loop60:
 5391  
             do {
 5392  0
                 int alt60=2;
 5393  0
                 switch ( input.LA(1) ) {
 5394  
                 case SILENT:
 5395  
                     {
 5396  0
                     alt60=1;
 5397  
                     }
 5398  
                     break;
 5399  
 
 5400  
                 }
 5401  
 
 5402  0
                 switch (alt60) {
 5403  
                     case 1 :
 5404  
                         // com\\googlecode\\sparkleg\\SparqlT.g:154:15: SILENT
 5405  
                         {
 5406  0
                         _last = (CommonTree)input.LT(1);
 5407  0
                         SILENT135=(CommonTree)match(input,SILENT,FOLLOW_SILENT_in_clear988); 
 5408  0
                         SILENT135_tree = (CommonTree)adaptor.dupNode(SILENT135);
 5409  
 
 5410  
 
 5411  0
                         adaptor.addChild(root_1, SILENT135_tree);
 5412  
 
 5413  
 
 5414  
                         }
 5415  0
                         break;
 5416  
 
 5417  
                     default :
 5418  0
                         break loop60;
 5419  
                 }
 5420  0
             } while (true);
 5421  
 
 5422  
 
 5423  0
             _last = (CommonTree)input.LT(1);
 5424  0
             pushFollow(FOLLOW_graphRefAll_in_clear991);
 5425  0
             graphRefAll136=graphRefAll();
 5426  
 
 5427  0
             state._fsp--;
 5428  
 
 5429  0
             adaptor.addChild(root_1, graphRefAll136.getTree());
 5430  
 
 5431  
 
 5432  0
             match(input, Token.UP, null); 
 5433  0
             adaptor.addChild(root_0, root_1);
 5434  0
             _last = _save_last_1;
 5435  
             }
 5436  
 
 5437  
 
 5438  
             }
 5439  
 
 5440  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 5441  
 
 5442  
         }
 5443  0
         catch (RecognitionException re) {
 5444  0
             reportError(re);
 5445  0
             recover(input,re);
 5446  
         }
 5447  
 
 5448  0
         finally {
 5449  
                 // do for sure before leaving
 5450  0
         }
 5451  0
         return retval;
 5452  
     }
 5453  
     // $ANTLR end "clear"
 5454  
 
 5455  
 
 5456  0
     public static class drop_return extends TreeRuleReturnScope {
 5457  
         CommonTree tree;
 5458  0
         public Object getTree() { return tree; }
 5459  
     };
 5460  
 
 5461  
 
 5462  
     // $ANTLR start "drop"
 5463  
     // com\\googlecode\\sparkleg\\SparqlT.g:157:1: drop : ^( DROP ( SILENT )* graphRefAll ) ;
 5464  
     public final SparqlT.drop_return drop() throws RecognitionException {
 5465  0
         SparqlT.drop_return retval = new SparqlT.drop_return();
 5466  0
         retval.start = input.LT(1);
 5467  
 
 5468  
 
 5469  0
         CommonTree root_0 = null;
 5470  
 
 5471  0
         CommonTree _first_0 = null;
 5472  0
         CommonTree _last = null;
 5473  
 
 5474  0
         CommonTree DROP137=null;
 5475  0
         CommonTree SILENT138=null;
 5476  0
         SparqlT.graphRefAll_return graphRefAll139 =null;
 5477  
 
 5478  
 
 5479  0
         CommonTree DROP137_tree=null;
 5480  0
         CommonTree SILENT138_tree=null;
 5481  
 
 5482  
         try {
 5483  
             // com\\googlecode\\sparkleg\\SparqlT.g:158:5: ( ^( DROP ( SILENT )* graphRefAll ) )
 5484  
             // com\\googlecode\\sparkleg\\SparqlT.g:158:7: ^( DROP ( SILENT )* graphRefAll )
 5485  
             {
 5486  0
             root_0 = (CommonTree)adaptor.nil();
 5487  
 
 5488  
 
 5489  0
             _last = (CommonTree)input.LT(1);
 5490  
             {
 5491  0
             CommonTree _save_last_1 = _last;
 5492  0
             CommonTree _first_1 = null;
 5493  0
             CommonTree root_1 = (CommonTree)adaptor.nil();
 5494  0
             _last = (CommonTree)input.LT(1);
 5495  0
             DROP137=(CommonTree)match(input,DROP,FOLLOW_DROP_in_drop1014); 
 5496  0
             DROP137_tree = (CommonTree)adaptor.dupNode(DROP137);
 5497  
 
 5498  
 
 5499  0
             root_1 = (CommonTree)adaptor.becomeRoot(DROP137_tree, root_1);
 5500  
 
 5501  
 
 5502  0
             match(input, Token.DOWN, null); 
 5503  
             // com\\googlecode\\sparkleg\\SparqlT.g:158:14: ( SILENT )*
 5504  
             loop61:
 5505  
             do {
 5506  0
                 int alt61=2;
 5507  0
                 switch ( input.LA(1) ) {
 5508  
                 case SILENT:
 5509  
                     {
 5510  0
                     alt61=1;
 5511  
                     }
 5512  
                     break;
 5513  
 
 5514  
                 }
 5515  
 
 5516  0
                 switch (alt61) {
 5517  
                     case 1 :
 5518  
                         // com\\googlecode\\sparkleg\\SparqlT.g:158:14: SILENT
 5519  
                         {
 5520  0
                         _last = (CommonTree)input.LT(1);
 5521  0
                         SILENT138=(CommonTree)match(input,SILENT,FOLLOW_SILENT_in_drop1016); 
 5522  0
                         SILENT138_tree = (CommonTree)adaptor.dupNode(SILENT138);
 5523  
 
 5524  
 
 5525  0
                         adaptor.addChild(root_1, SILENT138_tree);
 5526  
 
 5527  
 
 5528  
                         }
 5529  0
                         break;
 5530  
 
 5531  
                     default :
 5532  0
                         break loop61;
 5533  
                 }
 5534  0
             } while (true);
 5535  
 
 5536  
 
 5537  0
             _last = (CommonTree)input.LT(1);
 5538  0
             pushFollow(FOLLOW_graphRefAll_in_drop1019);
 5539  0
             graphRefAll139=graphRefAll();
 5540  
 
 5541  0
             state._fsp--;
 5542  
 
 5543  0
             adaptor.addChild(root_1, graphRefAll139.getTree());
 5544  
 
 5545  
 
 5546  0
             match(input, Token.UP, null); 
 5547  0
             adaptor.addChild(root_0, root_1);
 5548  0
             _last = _save_last_1;
 5549  
             }
 5550  
 
 5551  
 
 5552  
             }
 5553  
 
 5554  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 5555  
 
 5556  
         }
 5557  0
         catch (RecognitionException re) {
 5558  0
             reportError(re);
 5559  0
             recover(input,re);
 5560  
         }
 5561  
 
 5562  0
         finally {
 5563  
                 // do for sure before leaving
 5564  0
         }
 5565  0
         return retval;
 5566  
     }
 5567  
     // $ANTLR end "drop"
 5568  
 
 5569  
 
 5570  0
     public static class create_return extends TreeRuleReturnScope {
 5571  
         CommonTree tree;
 5572  0
         public Object getTree() { return tree; }
 5573  
     };
 5574  
 
 5575  
 
 5576  
     // $ANTLR start "create"
 5577  
     // com\\googlecode\\sparkleg\\SparqlT.g:161:1: create : ^( CREATE ( SILENT )* graphRef ) ;
 5578  
     public final SparqlT.create_return create() throws RecognitionException {
 5579  0
         SparqlT.create_return retval = new SparqlT.create_return();
 5580  0
         retval.start = input.LT(1);
 5581  
 
 5582  
 
 5583  0
         CommonTree root_0 = null;
 5584  
 
 5585  0
         CommonTree _first_0 = null;
 5586  0
         CommonTree _last = null;
 5587  
 
 5588  0
         CommonTree CREATE140=null;
 5589  0
         CommonTree SILENT141=null;
 5590  0
         SparqlT.graphRef_return graphRef142 =null;
 5591  
 
 5592  
 
 5593  0
         CommonTree CREATE140_tree=null;
 5594  0
         CommonTree SILENT141_tree=null;
 5595  
 
 5596  
         try {
 5597  
             // com\\googlecode\\sparkleg\\SparqlT.g:162:5: ( ^( CREATE ( SILENT )* graphRef ) )
 5598  
             // com\\googlecode\\sparkleg\\SparqlT.g:162:7: ^( CREATE ( SILENT )* graphRef )
 5599  
             {
 5600  0
             root_0 = (CommonTree)adaptor.nil();
 5601  
 
 5602  
 
 5603  0
             _last = (CommonTree)input.LT(1);
 5604  
             {
 5605  0
             CommonTree _save_last_1 = _last;
 5606  0
             CommonTree _first_1 = null;
 5607  0
             CommonTree root_1 = (CommonTree)adaptor.nil();
 5608  0
             _last = (CommonTree)input.LT(1);
 5609  0
             CREATE140=(CommonTree)match(input,CREATE,FOLLOW_CREATE_in_create1039); 
 5610  0
             CREATE140_tree = (CommonTree)adaptor.dupNode(CREATE140);
 5611  
 
 5612  
 
 5613  0
             root_1 = (CommonTree)adaptor.becomeRoot(CREATE140_tree, root_1);
 5614  
 
 5615  
 
 5616  0
             match(input, Token.DOWN, null); 
 5617  
             // com\\googlecode\\sparkleg\\SparqlT.g:162:16: ( SILENT )*
 5618  
             loop62:
 5619  
             do {
 5620  0
                 int alt62=2;
 5621  0
                 switch ( input.LA(1) ) {
 5622  
                 case SILENT:
 5623  
                     {
 5624  0
                     alt62=1;
 5625  
                     }
 5626  
                     break;
 5627  
 
 5628  
                 }
 5629  
 
 5630  0
                 switch (alt62) {
 5631  
                     case 1 :
 5632  
                         // com\\googlecode\\sparkleg\\SparqlT.g:162:16: SILENT
 5633  
                         {
 5634  0
                         _last = (CommonTree)input.LT(1);
 5635  0
                         SILENT141=(CommonTree)match(input,SILENT,FOLLOW_SILENT_in_create1041); 
 5636  0
                         SILENT141_tree = (CommonTree)adaptor.dupNode(SILENT141);
 5637  
 
 5638  
 
 5639  0
                         adaptor.addChild(root_1, SILENT141_tree);
 5640  
 
 5641  
 
 5642  
                         }
 5643  0
                         break;
 5644  
 
 5645  
                     default :
 5646  0
                         break loop62;
 5647  
                 }
 5648  0
             } while (true);
 5649  
 
 5650  
 
 5651  0
             _last = (CommonTree)input.LT(1);
 5652  0
             pushFollow(FOLLOW_graphRef_in_create1044);
 5653  0
             graphRef142=graphRef();
 5654  
 
 5655  0
             state._fsp--;
 5656  
 
 5657  0
             adaptor.addChild(root_1, graphRef142.getTree());
 5658  
 
 5659  
 
 5660  0
             match(input, Token.UP, null); 
 5661  0
             adaptor.addChild(root_0, root_1);
 5662  0
             _last = _save_last_1;
 5663  
             }
 5664  
 
 5665  
 
 5666  
             }
 5667  
 
 5668  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 5669  
 
 5670  
         }
 5671  0
         catch (RecognitionException re) {
 5672  0
             reportError(re);
 5673  0
             recover(input,re);
 5674  
         }
 5675  
 
 5676  0
         finally {
 5677  
                 // do for sure before leaving
 5678  0
         }
 5679  0
         return retval;
 5680  
     }
 5681  
     // $ANTLR end "create"
 5682  
 
 5683  
 
 5684  0
     public static class add_return extends TreeRuleReturnScope {
 5685  
         CommonTree tree;
 5686  0
         public Object getTree() { return tree; }
 5687  
     };
 5688  
 
 5689  
 
 5690  
     // $ANTLR start "add"
 5691  
     // com\\googlecode\\sparkleg\\SparqlT.g:165:1: add : ^( ADD ( SILENT )* graphOrDefault graphOrDefault ) ;
 5692  
     public final SparqlT.add_return add() throws RecognitionException {
 5693  0
         SparqlT.add_return retval = new SparqlT.add_return();
 5694  0
         retval.start = input.LT(1);
 5695  
 
 5696  
 
 5697  0
         CommonTree root_0 = null;
 5698  
 
 5699  0
         CommonTree _first_0 = null;
 5700  0
         CommonTree _last = null;
 5701  
 
 5702  0
         CommonTree ADD143=null;
 5703  0
         CommonTree SILENT144=null;
 5704  0
         SparqlT.graphOrDefault_return graphOrDefault145 =null;
 5705  
 
 5706  0
         SparqlT.graphOrDefault_return graphOrDefault146 =null;
 5707  
 
 5708  
 
 5709  0
         CommonTree ADD143_tree=null;
 5710  0
         CommonTree SILENT144_tree=null;
 5711  
 
 5712  
         try {
 5713  
             // com\\googlecode\\sparkleg\\SparqlT.g:166:5: ( ^( ADD ( SILENT )* graphOrDefault graphOrDefault ) )
 5714  
             // com\\googlecode\\sparkleg\\SparqlT.g:166:7: ^( ADD ( SILENT )* graphOrDefault graphOrDefault )
 5715  
             {
 5716  0
             root_0 = (CommonTree)adaptor.nil();
 5717  
 
 5718  
 
 5719  0
             _last = (CommonTree)input.LT(1);
 5720  
             {
 5721  0
             CommonTree _save_last_1 = _last;
 5722  0
             CommonTree _first_1 = null;
 5723  0
             CommonTree root_1 = (CommonTree)adaptor.nil();
 5724  0
             _last = (CommonTree)input.LT(1);
 5725  0
             ADD143=(CommonTree)match(input,ADD,FOLLOW_ADD_in_add1067); 
 5726  0
             ADD143_tree = (CommonTree)adaptor.dupNode(ADD143);
 5727  
 
 5728  
 
 5729  0
             root_1 = (CommonTree)adaptor.becomeRoot(ADD143_tree, root_1);
 5730  
 
 5731  
 
 5732  0
             match(input, Token.DOWN, null); 
 5733  
             // com\\googlecode\\sparkleg\\SparqlT.g:166:13: ( SILENT )*
 5734  
             loop63:
 5735  
             do {
 5736  0
                 int alt63=2;
 5737  0
                 switch ( input.LA(1) ) {
 5738  
                 case SILENT:
 5739  
                     {
 5740  0
                     alt63=1;
 5741  
                     }
 5742  
                     break;
 5743  
 
 5744  
                 }
 5745  
 
 5746  0
                 switch (alt63) {
 5747  
                     case 1 :
 5748  
                         // com\\googlecode\\sparkleg\\SparqlT.g:166:13: SILENT
 5749  
                         {
 5750  0
                         _last = (CommonTree)input.LT(1);
 5751  0
                         SILENT144=(CommonTree)match(input,SILENT,FOLLOW_SILENT_in_add1069); 
 5752  0
                         SILENT144_tree = (CommonTree)adaptor.dupNode(SILENT144);
 5753  
 
 5754  
 
 5755  0
                         adaptor.addChild(root_1, SILENT144_tree);
 5756  
 
 5757  
 
 5758  
                         }
 5759  0
                         break;
 5760  
 
 5761  
                     default :
 5762  0
                         break loop63;
 5763  
                 }
 5764  0
             } while (true);
 5765  
 
 5766  
 
 5767  0
             _last = (CommonTree)input.LT(1);
 5768  0
             pushFollow(FOLLOW_graphOrDefault_in_add1072);
 5769  0
             graphOrDefault145=graphOrDefault();
 5770  
 
 5771  0
             state._fsp--;
 5772  
 
 5773  0
             adaptor.addChild(root_1, graphOrDefault145.getTree());
 5774  
 
 5775  
 
 5776  0
             _last = (CommonTree)input.LT(1);
 5777  0
             pushFollow(FOLLOW_graphOrDefault_in_add1074);
 5778  0
             graphOrDefault146=graphOrDefault();
 5779  
 
 5780  0
             state._fsp--;
 5781  
 
 5782  0
             adaptor.addChild(root_1, graphOrDefault146.getTree());
 5783  
 
 5784  
 
 5785  0
             match(input, Token.UP, null); 
 5786  0
             adaptor.addChild(root_0, root_1);
 5787  0
             _last = _save_last_1;
 5788  
             }
 5789  
 
 5790  
 
 5791  
             }
 5792  
 
 5793  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 5794  
 
 5795  
         }
 5796  0
         catch (RecognitionException re) {
 5797  0
             reportError(re);
 5798  0
             recover(input,re);
 5799  
         }
 5800  
 
 5801  0
         finally {
 5802  
                 // do for sure before leaving
 5803  0
         }
 5804  0
         return retval;
 5805  
     }
 5806  
     // $ANTLR end "add"
 5807  
 
 5808  
 
 5809  0
     public static class move_return extends TreeRuleReturnScope {
 5810  
         CommonTree tree;
 5811  0
         public Object getTree() { return tree; }
 5812  
     };
 5813  
 
 5814  
 
 5815  
     // $ANTLR start "move"
 5816  
     // com\\googlecode\\sparkleg\\SparqlT.g:169:1: move : ^( MOVE ( SILENT )* graphOrDefault graphOrDefault ) ;
 5817  
     public final SparqlT.move_return move() throws RecognitionException {
 5818  0
         SparqlT.move_return retval = new SparqlT.move_return();
 5819  0
         retval.start = input.LT(1);
 5820  
 
 5821  
 
 5822  0
         CommonTree root_0 = null;
 5823  
 
 5824  0
         CommonTree _first_0 = null;
 5825  0
         CommonTree _last = null;
 5826  
 
 5827  0
         CommonTree MOVE147=null;
 5828  0
         CommonTree SILENT148=null;
 5829  0
         SparqlT.graphOrDefault_return graphOrDefault149 =null;
 5830  
 
 5831  0
         SparqlT.graphOrDefault_return graphOrDefault150 =null;
 5832  
 
 5833  
 
 5834  0
         CommonTree MOVE147_tree=null;
 5835  0
         CommonTree SILENT148_tree=null;
 5836  
 
 5837  
         try {
 5838  
             // com\\googlecode\\sparkleg\\SparqlT.g:170:5: ( ^( MOVE ( SILENT )* graphOrDefault graphOrDefault ) )
 5839  
             // com\\googlecode\\sparkleg\\SparqlT.g:170:7: ^( MOVE ( SILENT )* graphOrDefault graphOrDefault )
 5840  
             {
 5841  0
             root_0 = (CommonTree)adaptor.nil();
 5842  
 
 5843  
 
 5844  0
             _last = (CommonTree)input.LT(1);
 5845  
             {
 5846  0
             CommonTree _save_last_1 = _last;
 5847  0
             CommonTree _first_1 = null;
 5848  0
             CommonTree root_1 = (CommonTree)adaptor.nil();
 5849  0
             _last = (CommonTree)input.LT(1);
 5850  0
             MOVE147=(CommonTree)match(input,MOVE,FOLLOW_MOVE_in_move1097); 
 5851  0
             MOVE147_tree = (CommonTree)adaptor.dupNode(MOVE147);
 5852  
 
 5853  
 
 5854  0
             root_1 = (CommonTree)adaptor.becomeRoot(MOVE147_tree, root_1);
 5855  
 
 5856  
 
 5857  0
             match(input, Token.DOWN, null); 
 5858  
             // com\\googlecode\\sparkleg\\SparqlT.g:170:14: ( SILENT )*
 5859  
             loop64:
 5860  
             do {
 5861  0
                 int alt64=2;
 5862  0
                 switch ( input.LA(1) ) {
 5863  
                 case SILENT:
 5864  
                     {
 5865  0
                     alt64=1;
 5866  
                     }
 5867  
                     break;
 5868  
 
 5869  
                 }
 5870  
 
 5871  0
                 switch (alt64) {
 5872  
                     case 1 :
 5873  
                         // com\\googlecode\\sparkleg\\SparqlT.g:170:14: SILENT
 5874  
                         {
 5875  0
                         _last = (CommonTree)input.LT(1);
 5876  0
                         SILENT148=(CommonTree)match(input,SILENT,FOLLOW_SILENT_in_move1099); 
 5877  0
                         SILENT148_tree = (CommonTree)adaptor.dupNode(SILENT148);
 5878  
 
 5879  
 
 5880  0
                         adaptor.addChild(root_1, SILENT148_tree);
 5881  
 
 5882  
 
 5883  
                         }
 5884  0
                         break;
 5885  
 
 5886  
                     default :
 5887  0
                         break loop64;
 5888  
                 }
 5889  0
             } while (true);
 5890  
 
 5891  
 
 5892  0
             _last = (CommonTree)input.LT(1);
 5893  0
             pushFollow(FOLLOW_graphOrDefault_in_move1102);
 5894  0
             graphOrDefault149=graphOrDefault();
 5895  
 
 5896  0
             state._fsp--;
 5897  
 
 5898  0
             adaptor.addChild(root_1, graphOrDefault149.getTree());
 5899  
 
 5900  
 
 5901  0
             _last = (CommonTree)input.LT(1);
 5902  0
             pushFollow(FOLLOW_graphOrDefault_in_move1104);
 5903  0
             graphOrDefault150=graphOrDefault();
 5904  
 
 5905  0
             state._fsp--;
 5906  
 
 5907  0
             adaptor.addChild(root_1, graphOrDefault150.getTree());
 5908  
 
 5909  
 
 5910  0
             match(input, Token.UP, null); 
 5911  0
             adaptor.addChild(root_0, root_1);
 5912  0
             _last = _save_last_1;
 5913  
             }
 5914  
 
 5915  
 
 5916  
             }
 5917  
 
 5918  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 5919  
 
 5920  
         }
 5921  0
         catch (RecognitionException re) {
 5922  0
             reportError(re);
 5923  0
             recover(input,re);
 5924  
         }
 5925  
 
 5926  0
         finally {
 5927  
                 // do for sure before leaving
 5928  0
         }
 5929  0
         return retval;
 5930  
     }
 5931  
     // $ANTLR end "move"
 5932  
 
 5933  
 
 5934  0
     public static class copy_return extends TreeRuleReturnScope {
 5935  
         CommonTree tree;
 5936  0
         public Object getTree() { return tree; }
 5937  
     };
 5938  
 
 5939  
 
 5940  
     // $ANTLR start "copy"
 5941  
     // com\\googlecode\\sparkleg\\SparqlT.g:173:1: copy : ^( COPY ( SILENT )* graphOrDefault graphOrDefault ) ;
 5942  
     public final SparqlT.copy_return copy() throws RecognitionException {
 5943  0
         SparqlT.copy_return retval = new SparqlT.copy_return();
 5944  0
         retval.start = input.LT(1);
 5945  
 
 5946  
 
 5947  0
         CommonTree root_0 = null;
 5948  
 
 5949  0
         CommonTree _first_0 = null;
 5950  0
         CommonTree _last = null;
 5951  
 
 5952  0
         CommonTree COPY151=null;
 5953  0
         CommonTree SILENT152=null;
 5954  0
         SparqlT.graphOrDefault_return graphOrDefault153 =null;
 5955  
 
 5956  0
         SparqlT.graphOrDefault_return graphOrDefault154 =null;
 5957  
 
 5958  
 
 5959  0
         CommonTree COPY151_tree=null;
 5960  0
         CommonTree SILENT152_tree=null;
 5961  
 
 5962  
         try {
 5963  
             // com\\googlecode\\sparkleg\\SparqlT.g:174:5: ( ^( COPY ( SILENT )* graphOrDefault graphOrDefault ) )
 5964  
             // com\\googlecode\\sparkleg\\SparqlT.g:174:7: ^( COPY ( SILENT )* graphOrDefault graphOrDefault )
 5965  
             {
 5966  0
             root_0 = (CommonTree)adaptor.nil();
 5967  
 
 5968  
 
 5969  0
             _last = (CommonTree)input.LT(1);
 5970  
             {
 5971  0
             CommonTree _save_last_1 = _last;
 5972  0
             CommonTree _first_1 = null;
 5973  0
             CommonTree root_1 = (CommonTree)adaptor.nil();
 5974  0
             _last = (CommonTree)input.LT(1);
 5975  0
             COPY151=(CommonTree)match(input,COPY,FOLLOW_COPY_in_copy1127); 
 5976  0
             COPY151_tree = (CommonTree)adaptor.dupNode(COPY151);
 5977  
 
 5978  
 
 5979  0
             root_1 = (CommonTree)adaptor.becomeRoot(COPY151_tree, root_1);
 5980  
 
 5981  
 
 5982  0
             match(input, Token.DOWN, null); 
 5983  
             // com\\googlecode\\sparkleg\\SparqlT.g:174:14: ( SILENT )*
 5984  
             loop65:
 5985  
             do {
 5986  0
                 int alt65=2;
 5987  0
                 switch ( input.LA(1) ) {
 5988  
                 case SILENT:
 5989  
                     {
 5990  0
                     alt65=1;
 5991  
                     }
 5992  
                     break;
 5993  
 
 5994  
                 }
 5995  
 
 5996  0
                 switch (alt65) {
 5997  
                     case 1 :
 5998  
                         // com\\googlecode\\sparkleg\\SparqlT.g:174:14: SILENT
 5999  
                         {
 6000  0
                         _last = (CommonTree)input.LT(1);
 6001  0
                         SILENT152=(CommonTree)match(input,SILENT,FOLLOW_SILENT_in_copy1129); 
 6002  0
                         SILENT152_tree = (CommonTree)adaptor.dupNode(SILENT152);
 6003  
 
 6004  
 
 6005  0
                         adaptor.addChild(root_1, SILENT152_tree);
 6006  
 
 6007  
 
 6008  
                         }
 6009  0
                         break;
 6010  
 
 6011  
                     default :
 6012  0
                         break loop65;
 6013  
                 }
 6014  0
             } while (true);
 6015  
 
 6016  
 
 6017  0
             _last = (CommonTree)input.LT(1);
 6018  0
             pushFollow(FOLLOW_graphOrDefault_in_copy1132);
 6019  0
             graphOrDefault153=graphOrDefault();
 6020  
 
 6021  0
             state._fsp--;
 6022  
 
 6023  0
             adaptor.addChild(root_1, graphOrDefault153.getTree());
 6024  
 
 6025  
 
 6026  0
             _last = (CommonTree)input.LT(1);
 6027  0
             pushFollow(FOLLOW_graphOrDefault_in_copy1134);
 6028  0
             graphOrDefault154=graphOrDefault();
 6029  
 
 6030  0
             state._fsp--;
 6031  
 
 6032  0
             adaptor.addChild(root_1, graphOrDefault154.getTree());
 6033  
 
 6034  
 
 6035  0
             match(input, Token.UP, null); 
 6036  0
             adaptor.addChild(root_0, root_1);
 6037  0
             _last = _save_last_1;
 6038  
             }
 6039  
 
 6040  
 
 6041  
             }
 6042  
 
 6043  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 6044  
 
 6045  
         }
 6046  0
         catch (RecognitionException re) {
 6047  0
             reportError(re);
 6048  0
             recover(input,re);
 6049  
         }
 6050  
 
 6051  0
         finally {
 6052  
                 // do for sure before leaving
 6053  0
         }
 6054  0
         return retval;
 6055  
     }
 6056  
     // $ANTLR end "copy"
 6057  
 
 6058  
 
 6059  0
     public static class insert_return extends TreeRuleReturnScope {
 6060  
         CommonTree tree;
 6061  0
         public Object getTree() { return tree; }
 6062  
     };
 6063  
 
 6064  
 
 6065  
     // $ANTLR start "insert"
 6066  
     // com\\googlecode\\sparkleg\\SparqlT.g:177:1: insert : ^( INSERT DATA quadPattern ) ;
 6067  
     public final SparqlT.insert_return insert() throws RecognitionException {
 6068  0
         SparqlT.insert_return retval = new SparqlT.insert_return();
 6069  0
         retval.start = input.LT(1);
 6070  
 
 6071  
 
 6072  0
         CommonTree root_0 = null;
 6073  
 
 6074  0
         CommonTree _first_0 = null;
 6075  0
         CommonTree _last = null;
 6076  
 
 6077  0
         CommonTree INSERT155=null;
 6078  0
         CommonTree DATA156=null;
 6079  0
         SparqlT.quadPattern_return quadPattern157 =null;
 6080  
 
 6081  
 
 6082  0
         CommonTree INSERT155_tree=null;
 6083  0
         CommonTree DATA156_tree=null;
 6084  
 
 6085  
         try {
 6086  
             // com\\googlecode\\sparkleg\\SparqlT.g:178:5: ( ^( INSERT DATA quadPattern ) )
 6087  
             // com\\googlecode\\sparkleg\\SparqlT.g:178:7: ^( INSERT DATA quadPattern )
 6088  
             {
 6089  0
             root_0 = (CommonTree)adaptor.nil();
 6090  
 
 6091  
 
 6092  0
             _last = (CommonTree)input.LT(1);
 6093  
             {
 6094  0
             CommonTree _save_last_1 = _last;
 6095  0
             CommonTree _first_1 = null;
 6096  0
             CommonTree root_1 = (CommonTree)adaptor.nil();
 6097  0
             _last = (CommonTree)input.LT(1);
 6098  0
             INSERT155=(CommonTree)match(input,INSERT,FOLLOW_INSERT_in_insert1153); 
 6099  0
             INSERT155_tree = (CommonTree)adaptor.dupNode(INSERT155);
 6100  
 
 6101  
 
 6102  0
             root_1 = (CommonTree)adaptor.becomeRoot(INSERT155_tree, root_1);
 6103  
 
 6104  
 
 6105  0
             match(input, Token.DOWN, null); 
 6106  0
             _last = (CommonTree)input.LT(1);
 6107  0
             DATA156=(CommonTree)match(input,DATA,FOLLOW_DATA_in_insert1155); 
 6108  0
             DATA156_tree = (CommonTree)adaptor.dupNode(DATA156);
 6109  
 
 6110  
 
 6111  0
             adaptor.addChild(root_1, DATA156_tree);
 6112  
 
 6113  
 
 6114  0
             _last = (CommonTree)input.LT(1);
 6115  0
             pushFollow(FOLLOW_quadPattern_in_insert1157);
 6116  0
             quadPattern157=quadPattern();
 6117  
 
 6118  0
             state._fsp--;
 6119  
 
 6120  0
             adaptor.addChild(root_1, quadPattern157.getTree());
 6121  
 
 6122  
 
 6123  0
             match(input, Token.UP, null); 
 6124  0
             adaptor.addChild(root_0, root_1);
 6125  0
             _last = _save_last_1;
 6126  
             }
 6127  
 
 6128  
 
 6129  
             }
 6130  
 
 6131  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 6132  
 
 6133  
         }
 6134  0
         catch (RecognitionException re) {
 6135  0
             reportError(re);
 6136  0
             recover(input,re);
 6137  
         }
 6138  
 
 6139  0
         finally {
 6140  
                 // do for sure before leaving
 6141  0
         }
 6142  0
         return retval;
 6143  
     }
 6144  
     // $ANTLR end "insert"
 6145  
 
 6146  
 
 6147  0
     public static class delete_return extends TreeRuleReturnScope {
 6148  
         CommonTree tree;
 6149  0
         public Object getTree() { return tree; }
 6150  
     };
 6151  
 
 6152  
 
 6153  
     // $ANTLR start "delete"
 6154  
     // com\\googlecode\\sparkleg\\SparqlT.g:181:1: delete : DELETE ( deleteData | deleteWhere ) ;
 6155  
     public final SparqlT.delete_return delete() throws RecognitionException {
 6156  0
         SparqlT.delete_return retval = new SparqlT.delete_return();
 6157  0
         retval.start = input.LT(1);
 6158  
 
 6159  
 
 6160  0
         CommonTree root_0 = null;
 6161  
 
 6162  0
         CommonTree _first_0 = null;
 6163  0
         CommonTree _last = null;
 6164  
 
 6165  0
         CommonTree DELETE158=null;
 6166  0
         SparqlT.deleteData_return deleteData159 =null;
 6167  
 
 6168  0
         SparqlT.deleteWhere_return deleteWhere160 =null;
 6169  
 
 6170  
 
 6171  0
         CommonTree DELETE158_tree=null;
 6172  
 
 6173  
         try {
 6174  
             // com\\googlecode\\sparkleg\\SparqlT.g:182:5: ( DELETE ( deleteData | deleteWhere ) )
 6175  
             // com\\googlecode\\sparkleg\\SparqlT.g:182:7: DELETE ( deleteData | deleteWhere )
 6176  
             {
 6177  0
             root_0 = (CommonTree)adaptor.nil();
 6178  
 
 6179  
 
 6180  0
             _last = (CommonTree)input.LT(1);
 6181  0
             DELETE158=(CommonTree)match(input,DELETE,FOLLOW_DELETE_in_delete1182); 
 6182  0
             DELETE158_tree = (CommonTree)adaptor.dupNode(DELETE158);
 6183  
 
 6184  
 
 6185  0
             adaptor.addChild(root_0, DELETE158_tree);
 6186  
 
 6187  
 
 6188  
             // com\\googlecode\\sparkleg\\SparqlT.g:182:14: ( deleteData | deleteWhere )
 6189  0
             int alt66=2;
 6190  0
             switch ( input.LA(1) ) {
 6191  
             case DELETE:
 6192  
                 {
 6193  0
                 switch ( input.LA(2) ) {
 6194  
                 case DOWN:
 6195  
                     {
 6196  0
                     switch ( input.LA(3) ) {
 6197  
                     case DATA:
 6198  
                         {
 6199  0
                         alt66=1;
 6200  
                         }
 6201  0
                         break;
 6202  
                     case WHERE:
 6203  
                         {
 6204  0
                         alt66=2;
 6205  
                         }
 6206  0
                         break;
 6207  
                     default:
 6208  0
                         NoViableAltException nvae =
 6209  
                             new NoViableAltException("", 66, 2, input);
 6210  
 
 6211  0
                         throw nvae;
 6212  
 
 6213  
                     }
 6214  
 
 6215  
                     }
 6216  0
                     break;
 6217  
                 default:
 6218  0
                     NoViableAltException nvae =
 6219  
                         new NoViableAltException("", 66, 1, input);
 6220  
 
 6221  0
                     throw nvae;
 6222  
 
 6223  
                 }
 6224  
 
 6225  
                 }
 6226  0
                 break;
 6227  
             default:
 6228  0
                 NoViableAltException nvae =
 6229  
                     new NoViableAltException("", 66, 0, input);
 6230  
 
 6231  0
                 throw nvae;
 6232  
 
 6233  
             }
 6234  
 
 6235  0
             switch (alt66) {
 6236  
                 case 1 :
 6237  
                     // com\\googlecode\\sparkleg\\SparqlT.g:182:15: deleteData
 6238  
                     {
 6239  0
                     _last = (CommonTree)input.LT(1);
 6240  0
                     pushFollow(FOLLOW_deleteData_in_delete1185);
 6241  0
                     deleteData159=deleteData();
 6242  
 
 6243  0
                     state._fsp--;
 6244  
 
 6245  0
                     adaptor.addChild(root_0, deleteData159.getTree());
 6246  
 
 6247  
 
 6248  
                     }
 6249  0
                     break;
 6250  
                 case 2 :
 6251  
                     // com\\googlecode\\sparkleg\\SparqlT.g:182:28: deleteWhere
 6252  
                     {
 6253  0
                     _last = (CommonTree)input.LT(1);
 6254  0
                     pushFollow(FOLLOW_deleteWhere_in_delete1189);
 6255  0
                     deleteWhere160=deleteWhere();
 6256  
 
 6257  0
                     state._fsp--;
 6258  
 
 6259  0
                     adaptor.addChild(root_0, deleteWhere160.getTree());
 6260  
 
 6261  
 
 6262  
                     }
 6263  
                     break;
 6264  
 
 6265  
             }
 6266  
 
 6267  
 
 6268  
             }
 6269  
 
 6270  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 6271  
 
 6272  
         }
 6273  0
         catch (RecognitionException re) {
 6274  0
             reportError(re);
 6275  0
             recover(input,re);
 6276  
         }
 6277  
 
 6278  0
         finally {
 6279  
                 // do for sure before leaving
 6280  0
         }
 6281  0
         return retval;
 6282  
     }
 6283  
     // $ANTLR end "delete"
 6284  
 
 6285  
 
 6286  0
     public static class deleteData_return extends TreeRuleReturnScope {
 6287  
         CommonTree tree;
 6288  0
         public Object getTree() { return tree; }
 6289  
     };
 6290  
 
 6291  
 
 6292  
     // $ANTLR start "deleteData"
 6293  
     // com\\googlecode\\sparkleg\\SparqlT.g:185:1: deleteData : ^( DELETE DATA quadPattern ) ;
 6294  
     public final SparqlT.deleteData_return deleteData() throws RecognitionException {
 6295  0
         SparqlT.deleteData_return retval = new SparqlT.deleteData_return();
 6296  0
         retval.start = input.LT(1);
 6297  
 
 6298  
 
 6299  0
         CommonTree root_0 = null;
 6300  
 
 6301  0
         CommonTree _first_0 = null;
 6302  0
         CommonTree _last = null;
 6303  
 
 6304  0
         CommonTree DELETE161=null;
 6305  0
         CommonTree DATA162=null;
 6306  0
         SparqlT.quadPattern_return quadPattern163 =null;
 6307  
 
 6308  
 
 6309  0
         CommonTree DELETE161_tree=null;
 6310  0
         CommonTree DATA162_tree=null;
 6311  
 
 6312  
         try {
 6313  
             // com\\googlecode\\sparkleg\\SparqlT.g:186:5: ( ^( DELETE DATA quadPattern ) )
 6314  
             // com\\googlecode\\sparkleg\\SparqlT.g:186:7: ^( DELETE DATA quadPattern )
 6315  
             {
 6316  0
             root_0 = (CommonTree)adaptor.nil();
 6317  
 
 6318  
 
 6319  0
             _last = (CommonTree)input.LT(1);
 6320  
             {
 6321  0
             CommonTree _save_last_1 = _last;
 6322  0
             CommonTree _first_1 = null;
 6323  0
             CommonTree root_1 = (CommonTree)adaptor.nil();
 6324  0
             _last = (CommonTree)input.LT(1);
 6325  0
             DELETE161=(CommonTree)match(input,DELETE,FOLLOW_DELETE_in_deleteData1208); 
 6326  0
             DELETE161_tree = (CommonTree)adaptor.dupNode(DELETE161);
 6327  
 
 6328  
 
 6329  0
             root_1 = (CommonTree)adaptor.becomeRoot(DELETE161_tree, root_1);
 6330  
 
 6331  
 
 6332  0
             match(input, Token.DOWN, null); 
 6333  0
             _last = (CommonTree)input.LT(1);
 6334  0
             DATA162=(CommonTree)match(input,DATA,FOLLOW_DATA_in_deleteData1210); 
 6335  0
             DATA162_tree = (CommonTree)adaptor.dupNode(DATA162);
 6336  
 
 6337  
 
 6338  0
             adaptor.addChild(root_1, DATA162_tree);
 6339  
 
 6340  
 
 6341  0
             _last = (CommonTree)input.LT(1);
 6342  0
             pushFollow(FOLLOW_quadPattern_in_deleteData1212);
 6343  0
             quadPattern163=quadPattern();
 6344  
 
 6345  0
             state._fsp--;
 6346  
 
 6347  0
             adaptor.addChild(root_1, quadPattern163.getTree());
 6348  
 
 6349  
 
 6350  0
             match(input, Token.UP, null); 
 6351  0
             adaptor.addChild(root_0, root_1);
 6352  0
             _last = _save_last_1;
 6353  
             }
 6354  
 
 6355  
 
 6356  
             }
 6357  
 
 6358  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 6359  
 
 6360  
         }
 6361  0
         catch (RecognitionException re) {
 6362  0
             reportError(re);
 6363  0
             recover(input,re);
 6364  
         }
 6365  
 
 6366  0
         finally {
 6367  
                 // do for sure before leaving
 6368  0
         }
 6369  0
         return retval;
 6370  
     }
 6371  
     // $ANTLR end "deleteData"
 6372  
 
 6373  
 
 6374  0
     public static class deleteWhere_return extends TreeRuleReturnScope {
 6375  
         CommonTree tree;
 6376  0
         public Object getTree() { return tree; }
 6377  
     };
 6378  
 
 6379  
 
 6380  
     // $ANTLR start "deleteWhere"
 6381  
     // com\\googlecode\\sparkleg\\SparqlT.g:189:1: deleteWhere : ^( DELETE WHERE quadPattern ) ;
 6382  
     public final SparqlT.deleteWhere_return deleteWhere() throws RecognitionException {
 6383  0
         SparqlT.deleteWhere_return retval = new SparqlT.deleteWhere_return();
 6384  0
         retval.start = input.LT(1);
 6385  
 
 6386  
 
 6387  0
         CommonTree root_0 = null;
 6388  
 
 6389  0
         CommonTree _first_0 = null;
 6390  0
         CommonTree _last = null;
 6391  
 
 6392  0
         CommonTree DELETE164=null;
 6393  0
         CommonTree WHERE165=null;
 6394  0
         SparqlT.quadPattern_return quadPattern166 =null;
 6395  
 
 6396  
 
 6397  0
         CommonTree DELETE164_tree=null;
 6398  0
         CommonTree WHERE165_tree=null;
 6399  
 
 6400  
         try {
 6401  
             // com\\googlecode\\sparkleg\\SparqlT.g:190:5: ( ^( DELETE WHERE quadPattern ) )
 6402  
             // com\\googlecode\\sparkleg\\SparqlT.g:190:7: ^( DELETE WHERE quadPattern )
 6403  
             {
 6404  0
             root_0 = (CommonTree)adaptor.nil();
 6405  
 
 6406  
 
 6407  0
             _last = (CommonTree)input.LT(1);
 6408  
             {
 6409  0
             CommonTree _save_last_1 = _last;
 6410  0
             CommonTree _first_1 = null;
 6411  0
             CommonTree root_1 = (CommonTree)adaptor.nil();
 6412  0
             _last = (CommonTree)input.LT(1);
 6413  0
             DELETE164=(CommonTree)match(input,DELETE,FOLLOW_DELETE_in_deleteWhere1231); 
 6414  0
             DELETE164_tree = (CommonTree)adaptor.dupNode(DELETE164);
 6415  
 
 6416  
 
 6417  0
             root_1 = (CommonTree)adaptor.becomeRoot(DELETE164_tree, root_1);
 6418  
 
 6419  
 
 6420  0
             match(input, Token.DOWN, null); 
 6421  0
             _last = (CommonTree)input.LT(1);
 6422  0
             WHERE165=(CommonTree)match(input,WHERE,FOLLOW_WHERE_in_deleteWhere1233); 
 6423  0
             WHERE165_tree = (CommonTree)adaptor.dupNode(WHERE165);
 6424  
 
 6425  
 
 6426  0
             adaptor.addChild(root_1, WHERE165_tree);
 6427  
 
 6428  
 
 6429  0
             _last = (CommonTree)input.LT(1);
 6430  0
             pushFollow(FOLLOW_quadPattern_in_deleteWhere1235);
 6431  0
             quadPattern166=quadPattern();
 6432  
 
 6433  0
             state._fsp--;
 6434  
 
 6435  0
             adaptor.addChild(root_1, quadPattern166.getTree());
 6436  
 
 6437  
 
 6438  0
             match(input, Token.UP, null); 
 6439  0
             adaptor.addChild(root_0, root_1);
 6440  0
             _last = _save_last_1;
 6441  
             }
 6442  
 
 6443  
 
 6444  
             }
 6445  
 
 6446  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 6447  
 
 6448  
         }
 6449  0
         catch (RecognitionException re) {
 6450  0
             reportError(re);
 6451  0
             recover(input,re);
 6452  
         }
 6453  
 
 6454  0
         finally {
 6455  
                 // do for sure before leaving
 6456  0
         }
 6457  0
         return retval;
 6458  
     }
 6459  
     // $ANTLR end "deleteWhere"
 6460  
 
 6461  
 
 6462  0
     public static class modify_return extends TreeRuleReturnScope {
 6463  
         CommonTree tree;
 6464  0
         public Object getTree() { return tree; }
 6465  
     };
 6466  
 
 6467  
 
 6468  
     // $ANTLR start "modify"
 6469  
     // com\\googlecode\\sparkleg\\SparqlT.g:193:1: modify : ( ^( MODIFY ^( WITH iriRef ) ( deleteClause )* ( insertClause )* ( usingClause )* whereClause ) | ^( MODIFY ( deleteClause )* ( insertClause )* ( usingClause )* whereClause ) );
 6470  
     public final SparqlT.modify_return modify() throws RecognitionException {
 6471  0
         SparqlT.modify_return retval = new SparqlT.modify_return();
 6472  0
         retval.start = input.LT(1);
 6473  
 
 6474  
 
 6475  0
         CommonTree root_0 = null;
 6476  
 
 6477  0
         CommonTree _first_0 = null;
 6478  0
         CommonTree _last = null;
 6479  
 
 6480  0
         CommonTree MODIFY167=null;
 6481  0
         CommonTree WITH168=null;
 6482  0
         CommonTree MODIFY174=null;
 6483  0
         SparqlT.iriRef_return iriRef169 =null;
 6484  
 
 6485  0
         SparqlT.deleteClause_return deleteClause170 =null;
 6486  
 
 6487  0
         SparqlT.insertClause_return insertClause171 =null;
 6488  
 
 6489  0
         SparqlT.usingClause_return usingClause172 =null;
 6490  
 
 6491  0
         SparqlT.whereClause_return whereClause173 =null;
 6492  
 
 6493  0
         SparqlT.deleteClause_return deleteClause175 =null;
 6494  
 
 6495  0
         SparqlT.insertClause_return insertClause176 =null;
 6496  
 
 6497  0
         SparqlT.usingClause_return usingClause177 =null;
 6498  
 
 6499  0
         SparqlT.whereClause_return whereClause178 =null;
 6500  
 
 6501  
 
 6502  0
         CommonTree MODIFY167_tree=null;
 6503  0
         CommonTree WITH168_tree=null;
 6504  0
         CommonTree MODIFY174_tree=null;
 6505  
 
 6506  
         try {
 6507  
             // com\\googlecode\\sparkleg\\SparqlT.g:194:5: ( ^( MODIFY ^( WITH iriRef ) ( deleteClause )* ( insertClause )* ( usingClause )* whereClause ) | ^( MODIFY ( deleteClause )* ( insertClause )* ( usingClause )* whereClause ) )
 6508  0
             int alt73=2;
 6509  0
             switch ( input.LA(1) ) {
 6510  
             case MODIFY:
 6511  
                 {
 6512  0
                 switch ( input.LA(2) ) {
 6513  
                 case DOWN:
 6514  
                     {
 6515  0
                     switch ( input.LA(3) ) {
 6516  
                     case WITH:
 6517  
                         {
 6518  0
                         alt73=1;
 6519  
                         }
 6520  0
                         break;
 6521  
                     case DELETE:
 6522  
                     case INSERT:
 6523  
                     case USING:
 6524  
                     case WHERE_CLAUSE:
 6525  
                         {
 6526  0
                         alt73=2;
 6527  
                         }
 6528  0
                         break;
 6529  
                     default:
 6530  0
                         NoViableAltException nvae =
 6531  
                             new NoViableAltException("", 73, 2, input);
 6532  
 
 6533  0
                         throw nvae;
 6534  
 
 6535  
                     }
 6536  
 
 6537  
                     }
 6538  0
                     break;
 6539  
                 default:
 6540  0
                     NoViableAltException nvae =
 6541  
                         new NoViableAltException("", 73, 1, input);
 6542  
 
 6543  0
                     throw nvae;
 6544  
 
 6545  
                 }
 6546  
 
 6547  
                 }
 6548  0
                 break;
 6549  
             default:
 6550  0
                 NoViableAltException nvae =
 6551  
                     new NoViableAltException("", 73, 0, input);
 6552  
 
 6553  0
                 throw nvae;
 6554  
 
 6555  
             }
 6556  
 
 6557  0
             switch (alt73) {
 6558  
                 case 1 :
 6559  
                     // com\\googlecode\\sparkleg\\SparqlT.g:194:7: ^( MODIFY ^( WITH iriRef ) ( deleteClause )* ( insertClause )* ( usingClause )* whereClause )
 6560  
                     {
 6561  0
                     root_0 = (CommonTree)adaptor.nil();
 6562  
 
 6563  
 
 6564  0
                     _last = (CommonTree)input.LT(1);
 6565  
                     {
 6566  0
                     CommonTree _save_last_1 = _last;
 6567  0
                     CommonTree _first_1 = null;
 6568  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 6569  0
                     _last = (CommonTree)input.LT(1);
 6570  0
                     MODIFY167=(CommonTree)match(input,MODIFY,FOLLOW_MODIFY_in_modify1258); 
 6571  0
                     MODIFY167_tree = (CommonTree)adaptor.dupNode(MODIFY167);
 6572  
 
 6573  
 
 6574  0
                     root_1 = (CommonTree)adaptor.becomeRoot(MODIFY167_tree, root_1);
 6575  
 
 6576  
 
 6577  0
                     match(input, Token.DOWN, null); 
 6578  0
                     _last = (CommonTree)input.LT(1);
 6579  
                     {
 6580  0
                     CommonTree _save_last_2 = _last;
 6581  0
                     CommonTree _first_2 = null;
 6582  0
                     CommonTree root_2 = (CommonTree)adaptor.nil();
 6583  0
                     _last = (CommonTree)input.LT(1);
 6584  0
                     WITH168=(CommonTree)match(input,WITH,FOLLOW_WITH_in_modify1261); 
 6585  0
                     WITH168_tree = (CommonTree)adaptor.dupNode(WITH168);
 6586  
 
 6587  
 
 6588  0
                     root_2 = (CommonTree)adaptor.becomeRoot(WITH168_tree, root_2);
 6589  
 
 6590  
 
 6591  0
                     match(input, Token.DOWN, null); 
 6592  0
                     _last = (CommonTree)input.LT(1);
 6593  0
                     pushFollow(FOLLOW_iriRef_in_modify1263);
 6594  0
                     iriRef169=iriRef();
 6595  
 
 6596  0
                     state._fsp--;
 6597  
 
 6598  0
                     adaptor.addChild(root_2, iriRef169.getTree());
 6599  
 
 6600  
 
 6601  0
                     match(input, Token.UP, null); 
 6602  0
                     adaptor.addChild(root_1, root_2);
 6603  0
                     _last = _save_last_2;
 6604  
                     }
 6605  
 
 6606  
 
 6607  
                     // com\\googlecode\\sparkleg\\SparqlT.g:194:31: ( deleteClause )*
 6608  
                     loop67:
 6609  
                     do {
 6610  0
                         int alt67=2;
 6611  0
                         switch ( input.LA(1) ) {
 6612  
                         case DELETE:
 6613  
                             {
 6614  0
                             alt67=1;
 6615  
                             }
 6616  
                             break;
 6617  
 
 6618  
                         }
 6619  
 
 6620  0
                         switch (alt67) {
 6621  
                             case 1 :
 6622  
                                 // com\\googlecode\\sparkleg\\SparqlT.g:194:31: deleteClause
 6623  
                                 {
 6624  0
                                 _last = (CommonTree)input.LT(1);
 6625  0
                                 pushFollow(FOLLOW_deleteClause_in_modify1266);
 6626  0
                                 deleteClause170=deleteClause();
 6627  
 
 6628  0
                                 state._fsp--;
 6629  
 
 6630  0
                                 adaptor.addChild(root_1, deleteClause170.getTree());
 6631  
 
 6632  
 
 6633  
                                 }
 6634  0
                                 break;
 6635  
 
 6636  
                             default :
 6637  0
                                 break loop67;
 6638  
                         }
 6639  0
                     } while (true);
 6640  
 
 6641  
 
 6642  
                     // com\\googlecode\\sparkleg\\SparqlT.g:194:45: ( insertClause )*
 6643  
                     loop68:
 6644  
                     do {
 6645  0
                         int alt68=2;
 6646  0
                         switch ( input.LA(1) ) {
 6647  
                         case INSERT:
 6648  
                             {
 6649  0
                             alt68=1;
 6650  
                             }
 6651  
                             break;
 6652  
 
 6653  
                         }
 6654  
 
 6655  0
                         switch (alt68) {
 6656  
                             case 1 :
 6657  
                                 // com\\googlecode\\sparkleg\\SparqlT.g:194:45: insertClause
 6658  
                                 {
 6659  0
                                 _last = (CommonTree)input.LT(1);
 6660  0
                                 pushFollow(FOLLOW_insertClause_in_modify1269);
 6661  0
                                 insertClause171=insertClause();
 6662  
 
 6663  0
                                 state._fsp--;
 6664  
 
 6665  0
                                 adaptor.addChild(root_1, insertClause171.getTree());
 6666  
 
 6667  
 
 6668  
                                 }
 6669  0
                                 break;
 6670  
 
 6671  
                             default :
 6672  0
                                 break loop68;
 6673  
                         }
 6674  0
                     } while (true);
 6675  
 
 6676  
 
 6677  
                     // com\\googlecode\\sparkleg\\SparqlT.g:194:59: ( usingClause )*
 6678  
                     loop69:
 6679  
                     do {
 6680  0
                         int alt69=2;
 6681  0
                         switch ( input.LA(1) ) {
 6682  
                         case USING:
 6683  
                             {
 6684  0
                             alt69=1;
 6685  
                             }
 6686  
                             break;
 6687  
 
 6688  
                         }
 6689  
 
 6690  0
                         switch (alt69) {
 6691  
                             case 1 :
 6692  
                                 // com\\googlecode\\sparkleg\\SparqlT.g:194:59: usingClause
 6693  
                                 {
 6694  0
                                 _last = (CommonTree)input.LT(1);
 6695  0
                                 pushFollow(FOLLOW_usingClause_in_modify1272);
 6696  0
                                 usingClause172=usingClause();
 6697  
 
 6698  0
                                 state._fsp--;
 6699  
 
 6700  0
                                 adaptor.addChild(root_1, usingClause172.getTree());
 6701  
 
 6702  
 
 6703  
                                 }
 6704  0
                                 break;
 6705  
 
 6706  
                             default :
 6707  0
                                 break loop69;
 6708  
                         }
 6709  0
                     } while (true);
 6710  
 
 6711  
 
 6712  0
                     _last = (CommonTree)input.LT(1);
 6713  0
                     pushFollow(FOLLOW_whereClause_in_modify1275);
 6714  0
                     whereClause173=whereClause();
 6715  
 
 6716  0
                     state._fsp--;
 6717  
 
 6718  0
                     adaptor.addChild(root_1, whereClause173.getTree());
 6719  
 
 6720  
 
 6721  0
                     match(input, Token.UP, null); 
 6722  0
                     adaptor.addChild(root_0, root_1);
 6723  0
                     _last = _save_last_1;
 6724  
                     }
 6725  
 
 6726  
 
 6727  
                     }
 6728  0
                     break;
 6729  
                 case 2 :
 6730  
                     // com\\googlecode\\sparkleg\\SparqlT.g:195:7: ^( MODIFY ( deleteClause )* ( insertClause )* ( usingClause )* whereClause )
 6731  
                     {
 6732  0
                     root_0 = (CommonTree)adaptor.nil();
 6733  
 
 6734  
 
 6735  0
                     _last = (CommonTree)input.LT(1);
 6736  
                     {
 6737  0
                     CommonTree _save_last_1 = _last;
 6738  0
                     CommonTree _first_1 = null;
 6739  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 6740  0
                     _last = (CommonTree)input.LT(1);
 6741  0
                     MODIFY174=(CommonTree)match(input,MODIFY,FOLLOW_MODIFY_in_modify1285); 
 6742  0
                     MODIFY174_tree = (CommonTree)adaptor.dupNode(MODIFY174);
 6743  
 
 6744  
 
 6745  0
                     root_1 = (CommonTree)adaptor.becomeRoot(MODIFY174_tree, root_1);
 6746  
 
 6747  
 
 6748  0
                     match(input, Token.DOWN, null); 
 6749  
                     // com\\googlecode\\sparkleg\\SparqlT.g:195:16: ( deleteClause )*
 6750  
                     loop70:
 6751  
                     do {
 6752  0
                         int alt70=2;
 6753  0
                         switch ( input.LA(1) ) {
 6754  
                         case DELETE:
 6755  
                             {
 6756  0
                             alt70=1;
 6757  
                             }
 6758  
                             break;
 6759  
 
 6760  
                         }
 6761  
 
 6762  0
                         switch (alt70) {
 6763  
                             case 1 :
 6764  
                                 // com\\googlecode\\sparkleg\\SparqlT.g:195:16: deleteClause
 6765  
                                 {
 6766  0
                                 _last = (CommonTree)input.LT(1);
 6767  0
                                 pushFollow(FOLLOW_deleteClause_in_modify1287);
 6768  0
                                 deleteClause175=deleteClause();
 6769  
 
 6770  0
                                 state._fsp--;
 6771  
 
 6772  0
                                 adaptor.addChild(root_1, deleteClause175.getTree());
 6773  
 
 6774  
 
 6775  
                                 }
 6776  0
                                 break;
 6777  
 
 6778  
                             default :
 6779  0
                                 break loop70;
 6780  
                         }
 6781  0
                     } while (true);
 6782  
 
 6783  
 
 6784  
                     // com\\googlecode\\sparkleg\\SparqlT.g:195:30: ( insertClause )*
 6785  
                     loop71:
 6786  
                     do {
 6787  0
                         int alt71=2;
 6788  0
                         switch ( input.LA(1) ) {
 6789  
                         case INSERT:
 6790  
                             {
 6791  0
                             alt71=1;
 6792  
                             }
 6793  
                             break;
 6794  
 
 6795  
                         }
 6796  
 
 6797  0
                         switch (alt71) {
 6798  
                             case 1 :
 6799  
                                 // com\\googlecode\\sparkleg\\SparqlT.g:195:30: insertClause
 6800  
                                 {
 6801  0
                                 _last = (CommonTree)input.LT(1);
 6802  0
                                 pushFollow(FOLLOW_insertClause_in_modify1290);
 6803  0
                                 insertClause176=insertClause();
 6804  
 
 6805  0
                                 state._fsp--;
 6806  
 
 6807  0
                                 adaptor.addChild(root_1, insertClause176.getTree());
 6808  
 
 6809  
 
 6810  
                                 }
 6811  0
                                 break;
 6812  
 
 6813  
                             default :
 6814  0
                                 break loop71;
 6815  
                         }
 6816  0
                     } while (true);
 6817  
 
 6818  
 
 6819  
                     // com\\googlecode\\sparkleg\\SparqlT.g:195:44: ( usingClause )*
 6820  
                     loop72:
 6821  
                     do {
 6822  0
                         int alt72=2;
 6823  0
                         switch ( input.LA(1) ) {
 6824  
                         case USING:
 6825  
                             {
 6826  0
                             alt72=1;
 6827  
                             }
 6828  
                             break;
 6829  
 
 6830  
                         }
 6831  
 
 6832  0
                         switch (alt72) {
 6833  
                             case 1 :
 6834  
                                 // com\\googlecode\\sparkleg\\SparqlT.g:195:44: usingClause
 6835  
                                 {
 6836  0
                                 _last = (CommonTree)input.LT(1);
 6837  0
                                 pushFollow(FOLLOW_usingClause_in_modify1293);
 6838  0
                                 usingClause177=usingClause();
 6839  
 
 6840  0
                                 state._fsp--;
 6841  
 
 6842  0
                                 adaptor.addChild(root_1, usingClause177.getTree());
 6843  
 
 6844  
 
 6845  
                                 }
 6846  0
                                 break;
 6847  
 
 6848  
                             default :
 6849  0
                                 break loop72;
 6850  
                         }
 6851  0
                     } while (true);
 6852  
 
 6853  
 
 6854  0
                     _last = (CommonTree)input.LT(1);
 6855  0
                     pushFollow(FOLLOW_whereClause_in_modify1296);
 6856  0
                     whereClause178=whereClause();
 6857  
 
 6858  0
                     state._fsp--;
 6859  
 
 6860  0
                     adaptor.addChild(root_1, whereClause178.getTree());
 6861  
 
 6862  
 
 6863  0
                     match(input, Token.UP, null); 
 6864  0
                     adaptor.addChild(root_0, root_1);
 6865  0
                     _last = _save_last_1;
 6866  
                     }
 6867  
 
 6868  
 
 6869  
                     }
 6870  
                     break;
 6871  
 
 6872  
             }
 6873  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 6874  
 
 6875  
         }
 6876  0
         catch (RecognitionException re) {
 6877  0
             reportError(re);
 6878  0
             recover(input,re);
 6879  
         }
 6880  
 
 6881  0
         finally {
 6882  
                 // do for sure before leaving
 6883  0
         }
 6884  0
         return retval;
 6885  
     }
 6886  
     // $ANTLR end "modify"
 6887  
 
 6888  
 
 6889  0
     public static class deleteClause_return extends TreeRuleReturnScope {
 6890  
         CommonTree tree;
 6891  0
         public Object getTree() { return tree; }
 6892  
     };
 6893  
 
 6894  
 
 6895  
     // $ANTLR start "deleteClause"
 6896  
     // com\\googlecode\\sparkleg\\SparqlT.g:198:1: deleteClause : DELETE quadPattern ;
 6897  
     public final SparqlT.deleteClause_return deleteClause() throws RecognitionException {
 6898  0
         SparqlT.deleteClause_return retval = new SparqlT.deleteClause_return();
 6899  0
         retval.start = input.LT(1);
 6900  
 
 6901  
 
 6902  0
         CommonTree root_0 = null;
 6903  
 
 6904  0
         CommonTree _first_0 = null;
 6905  0
         CommonTree _last = null;
 6906  
 
 6907  0
         CommonTree DELETE179=null;
 6908  0
         SparqlT.quadPattern_return quadPattern180 =null;
 6909  
 
 6910  
 
 6911  0
         CommonTree DELETE179_tree=null;
 6912  
 
 6913  
         try {
 6914  
             // com\\googlecode\\sparkleg\\SparqlT.g:199:5: ( DELETE quadPattern )
 6915  
             // com\\googlecode\\sparkleg\\SparqlT.g:199:7: DELETE quadPattern
 6916  
             {
 6917  0
             root_0 = (CommonTree)adaptor.nil();
 6918  
 
 6919  
 
 6920  0
             _last = (CommonTree)input.LT(1);
 6921  0
             DELETE179=(CommonTree)match(input,DELETE,FOLLOW_DELETE_in_deleteClause1316); 
 6922  0
             DELETE179_tree = (CommonTree)adaptor.dupNode(DELETE179);
 6923  
 
 6924  
 
 6925  0
             adaptor.addChild(root_0, DELETE179_tree);
 6926  
 
 6927  
 
 6928  0
             _last = (CommonTree)input.LT(1);
 6929  0
             pushFollow(FOLLOW_quadPattern_in_deleteClause1318);
 6930  0
             quadPattern180=quadPattern();
 6931  
 
 6932  0
             state._fsp--;
 6933  
 
 6934  0
             adaptor.addChild(root_0, quadPattern180.getTree());
 6935  
 
 6936  
 
 6937  
             }
 6938  
 
 6939  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 6940  
 
 6941  
         }
 6942  0
         catch (RecognitionException re) {
 6943  0
             reportError(re);
 6944  0
             recover(input,re);
 6945  
         }
 6946  
 
 6947  0
         finally {
 6948  
                 // do for sure before leaving
 6949  0
         }
 6950  0
         return retval;
 6951  
     }
 6952  
     // $ANTLR end "deleteClause"
 6953  
 
 6954  
 
 6955  0
     public static class insertClause_return extends TreeRuleReturnScope {
 6956  
         CommonTree tree;
 6957  0
         public Object getTree() { return tree; }
 6958  
     };
 6959  
 
 6960  
 
 6961  
     // $ANTLR start "insertClause"
 6962  
     // com\\googlecode\\sparkleg\\SparqlT.g:202:1: insertClause : INSERT quadPattern ;
 6963  
     public final SparqlT.insertClause_return insertClause() throws RecognitionException {
 6964  0
         SparqlT.insertClause_return retval = new SparqlT.insertClause_return();
 6965  0
         retval.start = input.LT(1);
 6966  
 
 6967  
 
 6968  0
         CommonTree root_0 = null;
 6969  
 
 6970  0
         CommonTree _first_0 = null;
 6971  0
         CommonTree _last = null;
 6972  
 
 6973  0
         CommonTree INSERT181=null;
 6974  0
         SparqlT.quadPattern_return quadPattern182 =null;
 6975  
 
 6976  
 
 6977  0
         CommonTree INSERT181_tree=null;
 6978  
 
 6979  
         try {
 6980  
             // com\\googlecode\\sparkleg\\SparqlT.g:203:5: ( INSERT quadPattern )
 6981  
             // com\\googlecode\\sparkleg\\SparqlT.g:203:7: INSERT quadPattern
 6982  
             {
 6983  0
             root_0 = (CommonTree)adaptor.nil();
 6984  
 
 6985  
 
 6986  0
             _last = (CommonTree)input.LT(1);
 6987  0
             INSERT181=(CommonTree)match(input,INSERT,FOLLOW_INSERT_in_insertClause1341); 
 6988  0
             INSERT181_tree = (CommonTree)adaptor.dupNode(INSERT181);
 6989  
 
 6990  
 
 6991  0
             adaptor.addChild(root_0, INSERT181_tree);
 6992  
 
 6993  
 
 6994  0
             _last = (CommonTree)input.LT(1);
 6995  0
             pushFollow(FOLLOW_quadPattern_in_insertClause1343);
 6996  0
             quadPattern182=quadPattern();
 6997  
 
 6998  0
             state._fsp--;
 6999  
 
 7000  0
             adaptor.addChild(root_0, quadPattern182.getTree());
 7001  
 
 7002  
 
 7003  
             }
 7004  
 
 7005  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 7006  
 
 7007  
         }
 7008  0
         catch (RecognitionException re) {
 7009  0
             reportError(re);
 7010  0
             recover(input,re);
 7011  
         }
 7012  
 
 7013  0
         finally {
 7014  
                 // do for sure before leaving
 7015  0
         }
 7016  0
         return retval;
 7017  
     }
 7018  
     // $ANTLR end "insertClause"
 7019  
 
 7020  
 
 7021  0
     public static class usingClause_return extends TreeRuleReturnScope {
 7022  
         CommonTree tree;
 7023  0
         public Object getTree() { return tree; }
 7024  
     };
 7025  
 
 7026  
 
 7027  
     // $ANTLR start "usingClause"
 7028  
     // com\\googlecode\\sparkleg\\SparqlT.g:206:1: usingClause : ^( USING ( NAMED )? iriRef ) ;
 7029  
     public final SparqlT.usingClause_return usingClause() throws RecognitionException {
 7030  0
         SparqlT.usingClause_return retval = new SparqlT.usingClause_return();
 7031  0
         retval.start = input.LT(1);
 7032  
 
 7033  
 
 7034  0
         CommonTree root_0 = null;
 7035  
 
 7036  0
         CommonTree _first_0 = null;
 7037  0
         CommonTree _last = null;
 7038  
 
 7039  0
         CommonTree USING183=null;
 7040  0
         CommonTree NAMED184=null;
 7041  0
         SparqlT.iriRef_return iriRef185 =null;
 7042  
 
 7043  
 
 7044  0
         CommonTree USING183_tree=null;
 7045  0
         CommonTree NAMED184_tree=null;
 7046  
 
 7047  
         try {
 7048  
             // com\\googlecode\\sparkleg\\SparqlT.g:207:5: ( ^( USING ( NAMED )? iriRef ) )
 7049  
             // com\\googlecode\\sparkleg\\SparqlT.g:207:7: ^( USING ( NAMED )? iriRef )
 7050  
             {
 7051  0
             root_0 = (CommonTree)adaptor.nil();
 7052  
 
 7053  
 
 7054  0
             _last = (CommonTree)input.LT(1);
 7055  
             {
 7056  0
             CommonTree _save_last_1 = _last;
 7057  0
             CommonTree _first_1 = null;
 7058  0
             CommonTree root_1 = (CommonTree)adaptor.nil();
 7059  0
             _last = (CommonTree)input.LT(1);
 7060  0
             USING183=(CommonTree)match(input,USING,FOLLOW_USING_in_usingClause1361); 
 7061  0
             USING183_tree = (CommonTree)adaptor.dupNode(USING183);
 7062  
 
 7063  
 
 7064  0
             root_1 = (CommonTree)adaptor.becomeRoot(USING183_tree, root_1);
 7065  
 
 7066  
 
 7067  0
             match(input, Token.DOWN, null); 
 7068  
             // com\\googlecode\\sparkleg\\SparqlT.g:207:15: ( NAMED )?
 7069  0
             int alt74=2;
 7070  0
             switch ( input.LA(1) ) {
 7071  
                 case NAMED:
 7072  
                     {
 7073  0
                     alt74=1;
 7074  
                     }
 7075  
                     break;
 7076  
             }
 7077  
 
 7078  0
             switch (alt74) {
 7079  
                 case 1 :
 7080  
                     // com\\googlecode\\sparkleg\\SparqlT.g:207:15: NAMED
 7081  
                     {
 7082  0
                     _last = (CommonTree)input.LT(1);
 7083  0
                     NAMED184=(CommonTree)match(input,NAMED,FOLLOW_NAMED_in_usingClause1363); 
 7084  0
                     NAMED184_tree = (CommonTree)adaptor.dupNode(NAMED184);
 7085  
 
 7086  
 
 7087  0
                     adaptor.addChild(root_1, NAMED184_tree);
 7088  
 
 7089  
 
 7090  
                     }
 7091  
                     break;
 7092  
 
 7093  
             }
 7094  
 
 7095  
 
 7096  0
             _last = (CommonTree)input.LT(1);
 7097  0
             pushFollow(FOLLOW_iriRef_in_usingClause1366);
 7098  0
             iriRef185=iriRef();
 7099  
 
 7100  0
             state._fsp--;
 7101  
 
 7102  0
             adaptor.addChild(root_1, iriRef185.getTree());
 7103  
 
 7104  
 
 7105  0
             match(input, Token.UP, null); 
 7106  0
             adaptor.addChild(root_0, root_1);
 7107  0
             _last = _save_last_1;
 7108  
             }
 7109  
 
 7110  
 
 7111  
             }
 7112  
 
 7113  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 7114  
 
 7115  
         }
 7116  0
         catch (RecognitionException re) {
 7117  0
             reportError(re);
 7118  0
             recover(input,re);
 7119  
         }
 7120  
 
 7121  0
         finally {
 7122  
                 // do for sure before leaving
 7123  0
         }
 7124  0
         return retval;
 7125  
     }
 7126  
     // $ANTLR end "usingClause"
 7127  
 
 7128  
 
 7129  0
     public static class graphOrDefault_return extends TreeRuleReturnScope {
 7130  
         CommonTree tree;
 7131  0
         public Object getTree() { return tree; }
 7132  
     };
 7133  
 
 7134  
 
 7135  
     // $ANTLR start "graphOrDefault"
 7136  
     // com\\googlecode\\sparkleg\\SparqlT.g:210:1: graphOrDefault : ( DEFAULT | ( GRAPH )? iriRef );
 7137  
     public final SparqlT.graphOrDefault_return graphOrDefault() throws RecognitionException {
 7138  0
         SparqlT.graphOrDefault_return retval = new SparqlT.graphOrDefault_return();
 7139  0
         retval.start = input.LT(1);
 7140  
 
 7141  
 
 7142  0
         CommonTree root_0 = null;
 7143  
 
 7144  0
         CommonTree _first_0 = null;
 7145  0
         CommonTree _last = null;
 7146  
 
 7147  0
         CommonTree DEFAULT186=null;
 7148  0
         CommonTree GRAPH187=null;
 7149  0
         SparqlT.iriRef_return iriRef188 =null;
 7150  
 
 7151  
 
 7152  0
         CommonTree DEFAULT186_tree=null;
 7153  0
         CommonTree GRAPH187_tree=null;
 7154  
 
 7155  
         try {
 7156  
             // com\\googlecode\\sparkleg\\SparqlT.g:211:5: ( DEFAULT | ( GRAPH )? iriRef )
 7157  0
             int alt76=2;
 7158  0
             switch ( input.LA(1) ) {
 7159  
             case DEFAULT:
 7160  
                 {
 7161  0
                 alt76=1;
 7162  
                 }
 7163  0
                 break;
 7164  
             case GRAPH:
 7165  
             case IRI_REF:
 7166  
             case PNAME_LN:
 7167  
             case PNAME_NS:
 7168  
                 {
 7169  0
                 alt76=2;
 7170  
                 }
 7171  0
                 break;
 7172  
             default:
 7173  0
                 NoViableAltException nvae =
 7174  
                     new NoViableAltException("", 76, 0, input);
 7175  
 
 7176  0
                 throw nvae;
 7177  
 
 7178  
             }
 7179  
 
 7180  0
             switch (alt76) {
 7181  
                 case 1 :
 7182  
                     // com\\googlecode\\sparkleg\\SparqlT.g:211:7: DEFAULT
 7183  
                     {
 7184  0
                     root_0 = (CommonTree)adaptor.nil();
 7185  
 
 7186  
 
 7187  0
                     _last = (CommonTree)input.LT(1);
 7188  0
                     DEFAULT186=(CommonTree)match(input,DEFAULT,FOLLOW_DEFAULT_in_graphOrDefault1387); 
 7189  0
                     DEFAULT186_tree = (CommonTree)adaptor.dupNode(DEFAULT186);
 7190  
 
 7191  
 
 7192  0
                     adaptor.addChild(root_0, DEFAULT186_tree);
 7193  
 
 7194  
 
 7195  
                     }
 7196  0
                     break;
 7197  
                 case 2 :
 7198  
                     // com\\googlecode\\sparkleg\\SparqlT.g:212:7: ( GRAPH )? iriRef
 7199  
                     {
 7200  0
                     root_0 = (CommonTree)adaptor.nil();
 7201  
 
 7202  
 
 7203  
                     // com\\googlecode\\sparkleg\\SparqlT.g:212:7: ( GRAPH )?
 7204  0
                     int alt75=2;
 7205  0
                     switch ( input.LA(1) ) {
 7206  
                         case GRAPH:
 7207  
                             {
 7208  0
                             alt75=1;
 7209  
                             }
 7210  
                             break;
 7211  
                     }
 7212  
 
 7213  0
                     switch (alt75) {
 7214  
                         case 1 :
 7215  
                             // com\\googlecode\\sparkleg\\SparqlT.g:212:7: GRAPH
 7216  
                             {
 7217  0
                             _last = (CommonTree)input.LT(1);
 7218  0
                             GRAPH187=(CommonTree)match(input,GRAPH,FOLLOW_GRAPH_in_graphOrDefault1396); 
 7219  0
                             GRAPH187_tree = (CommonTree)adaptor.dupNode(GRAPH187);
 7220  
 
 7221  
 
 7222  0
                             adaptor.addChild(root_0, GRAPH187_tree);
 7223  
 
 7224  
 
 7225  
                             }
 7226  
                             break;
 7227  
 
 7228  
                     }
 7229  
 
 7230  
 
 7231  0
                     _last = (CommonTree)input.LT(1);
 7232  0
                     pushFollow(FOLLOW_iriRef_in_graphOrDefault1399);
 7233  0
                     iriRef188=iriRef();
 7234  
 
 7235  0
                     state._fsp--;
 7236  
 
 7237  0
                     adaptor.addChild(root_0, iriRef188.getTree());
 7238  
 
 7239  
 
 7240  
                     }
 7241  
                     break;
 7242  
 
 7243  
             }
 7244  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 7245  
 
 7246  
         }
 7247  0
         catch (RecognitionException re) {
 7248  0
             reportError(re);
 7249  0
             recover(input,re);
 7250  
         }
 7251  
 
 7252  0
         finally {
 7253  
                 // do for sure before leaving
 7254  0
         }
 7255  0
         return retval;
 7256  
     }
 7257  
     // $ANTLR end "graphOrDefault"
 7258  
 
 7259  
 
 7260  0
     public static class graphRef_return extends TreeRuleReturnScope {
 7261  
         CommonTree tree;
 7262  0
         public Object getTree() { return tree; }
 7263  
     };
 7264  
 
 7265  
 
 7266  
     // $ANTLR start "graphRef"
 7267  
     // com\\googlecode\\sparkleg\\SparqlT.g:215:1: graphRef : GRAPH iriRef ;
 7268  
     public final SparqlT.graphRef_return graphRef() throws RecognitionException {
 7269  0
         SparqlT.graphRef_return retval = new SparqlT.graphRef_return();
 7270  0
         retval.start = input.LT(1);
 7271  
 
 7272  
 
 7273  0
         CommonTree root_0 = null;
 7274  
 
 7275  0
         CommonTree _first_0 = null;
 7276  0
         CommonTree _last = null;
 7277  
 
 7278  0
         CommonTree GRAPH189=null;
 7279  0
         SparqlT.iriRef_return iriRef190 =null;
 7280  
 
 7281  
 
 7282  0
         CommonTree GRAPH189_tree=null;
 7283  
 
 7284  
         try {
 7285  
             // com\\googlecode\\sparkleg\\SparqlT.g:216:5: ( GRAPH iriRef )
 7286  
             // com\\googlecode\\sparkleg\\SparqlT.g:216:7: GRAPH iriRef
 7287  
             {
 7288  0
             root_0 = (CommonTree)adaptor.nil();
 7289  
 
 7290  
 
 7291  0
             _last = (CommonTree)input.LT(1);
 7292  0
             GRAPH189=(CommonTree)match(input,GRAPH,FOLLOW_GRAPH_in_graphRef1426); 
 7293  0
             GRAPH189_tree = (CommonTree)adaptor.dupNode(GRAPH189);
 7294  
 
 7295  
 
 7296  0
             adaptor.addChild(root_0, GRAPH189_tree);
 7297  
 
 7298  
 
 7299  0
             _last = (CommonTree)input.LT(1);
 7300  0
             pushFollow(FOLLOW_iriRef_in_graphRef1428);
 7301  0
             iriRef190=iriRef();
 7302  
 
 7303  0
             state._fsp--;
 7304  
 
 7305  0
             adaptor.addChild(root_0, iriRef190.getTree());
 7306  
 
 7307  
 
 7308  
             }
 7309  
 
 7310  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 7311  
 
 7312  
         }
 7313  0
         catch (RecognitionException re) {
 7314  0
             reportError(re);
 7315  0
             recover(input,re);
 7316  
         }
 7317  
 
 7318  0
         finally {
 7319  
                 // do for sure before leaving
 7320  0
         }
 7321  0
         return retval;
 7322  
     }
 7323  
     // $ANTLR end "graphRef"
 7324  
 
 7325  
 
 7326  0
     public static class graphRefAll_return extends TreeRuleReturnScope {
 7327  
         CommonTree tree;
 7328  0
         public Object getTree() { return tree; }
 7329  
     };
 7330  
 
 7331  
 
 7332  
     // $ANTLR start "graphRefAll"
 7333  
     // com\\googlecode\\sparkleg\\SparqlT.g:219:1: graphRefAll : ( graphRef | DEFAULT | NAMED | ALL );
 7334  
     public final SparqlT.graphRefAll_return graphRefAll() throws RecognitionException {
 7335  0
         SparqlT.graphRefAll_return retval = new SparqlT.graphRefAll_return();
 7336  0
         retval.start = input.LT(1);
 7337  
 
 7338  
 
 7339  0
         CommonTree root_0 = null;
 7340  
 
 7341  0
         CommonTree _first_0 = null;
 7342  0
         CommonTree _last = null;
 7343  
 
 7344  0
         CommonTree DEFAULT192=null;
 7345  0
         CommonTree NAMED193=null;
 7346  0
         CommonTree ALL194=null;
 7347  0
         SparqlT.graphRef_return graphRef191 =null;
 7348  
 
 7349  
 
 7350  0
         CommonTree DEFAULT192_tree=null;
 7351  0
         CommonTree NAMED193_tree=null;
 7352  0
         CommonTree ALL194_tree=null;
 7353  
 
 7354  
         try {
 7355  
             // com\\googlecode\\sparkleg\\SparqlT.g:220:5: ( graphRef | DEFAULT | NAMED | ALL )
 7356  0
             int alt77=4;
 7357  0
             switch ( input.LA(1) ) {
 7358  
             case GRAPH:
 7359  
                 {
 7360  0
                 alt77=1;
 7361  
                 }
 7362  0
                 break;
 7363  
             case DEFAULT:
 7364  
                 {
 7365  0
                 alt77=2;
 7366  
                 }
 7367  0
                 break;
 7368  
             case NAMED:
 7369  
                 {
 7370  0
                 alt77=3;
 7371  
                 }
 7372  0
                 break;
 7373  
             case ALL:
 7374  
                 {
 7375  0
                 alt77=4;
 7376  
                 }
 7377  0
                 break;
 7378  
             default:
 7379  0
                 NoViableAltException nvae =
 7380  
                     new NoViableAltException("", 77, 0, input);
 7381  
 
 7382  0
                 throw nvae;
 7383  
 
 7384  
             }
 7385  
 
 7386  0
             switch (alt77) {
 7387  
                 case 1 :
 7388  
                     // com\\googlecode\\sparkleg\\SparqlT.g:220:7: graphRef
 7389  
                     {
 7390  0
                     root_0 = (CommonTree)adaptor.nil();
 7391  
 
 7392  
 
 7393  0
                     _last = (CommonTree)input.LT(1);
 7394  0
                     pushFollow(FOLLOW_graphRef_in_graphRefAll1445);
 7395  0
                     graphRef191=graphRef();
 7396  
 
 7397  0
                     state._fsp--;
 7398  
 
 7399  0
                     adaptor.addChild(root_0, graphRef191.getTree());
 7400  
 
 7401  
 
 7402  
                     }
 7403  0
                     break;
 7404  
                 case 2 :
 7405  
                     // com\\googlecode\\sparkleg\\SparqlT.g:220:18: DEFAULT
 7406  
                     {
 7407  0
                     root_0 = (CommonTree)adaptor.nil();
 7408  
 
 7409  
 
 7410  0
                     _last = (CommonTree)input.LT(1);
 7411  0
                     DEFAULT192=(CommonTree)match(input,DEFAULT,FOLLOW_DEFAULT_in_graphRefAll1449); 
 7412  0
                     DEFAULT192_tree = (CommonTree)adaptor.dupNode(DEFAULT192);
 7413  
 
 7414  
 
 7415  0
                     adaptor.addChild(root_0, DEFAULT192_tree);
 7416  
 
 7417  
 
 7418  
                     }
 7419  0
                     break;
 7420  
                 case 3 :
 7421  
                     // com\\googlecode\\sparkleg\\SparqlT.g:220:28: NAMED
 7422  
                     {
 7423  0
                     root_0 = (CommonTree)adaptor.nil();
 7424  
 
 7425  
 
 7426  0
                     _last = (CommonTree)input.LT(1);
 7427  0
                     NAMED193=(CommonTree)match(input,NAMED,FOLLOW_NAMED_in_graphRefAll1453); 
 7428  0
                     NAMED193_tree = (CommonTree)adaptor.dupNode(NAMED193);
 7429  
 
 7430  
 
 7431  0
                     adaptor.addChild(root_0, NAMED193_tree);
 7432  
 
 7433  
 
 7434  
                     }
 7435  0
                     break;
 7436  
                 case 4 :
 7437  
                     // com\\googlecode\\sparkleg\\SparqlT.g:220:36: ALL
 7438  
                     {
 7439  0
                     root_0 = (CommonTree)adaptor.nil();
 7440  
 
 7441  
 
 7442  0
                     _last = (CommonTree)input.LT(1);
 7443  0
                     ALL194=(CommonTree)match(input,ALL,FOLLOW_ALL_in_graphRefAll1457); 
 7444  0
                     ALL194_tree = (CommonTree)adaptor.dupNode(ALL194);
 7445  
 
 7446  
 
 7447  0
                     adaptor.addChild(root_0, ALL194_tree);
 7448  
 
 7449  
 
 7450  
                     }
 7451  
                     break;
 7452  
 
 7453  
             }
 7454  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 7455  
 
 7456  
         }
 7457  0
         catch (RecognitionException re) {
 7458  0
             reportError(re);
 7459  0
             recover(input,re);
 7460  
         }
 7461  
 
 7462  0
         finally {
 7463  
                 // do for sure before leaving
 7464  0
         }
 7465  0
         return retval;
 7466  
     }
 7467  
     // $ANTLR end "graphRefAll"
 7468  
 
 7469  
 
 7470  0
     public static class quadPattern_return extends TreeRuleReturnScope {
 7471  
         CommonTree tree;
 7472  0
         public Object getTree() { return tree; }
 7473  
     };
 7474  
 
 7475  
 
 7476  
     // $ANTLR start "quadPattern"
 7477  
     // com\\googlecode\\sparkleg\\SparqlT.g:223:1: quadPattern : quads ;
 7478  
     public final SparqlT.quadPattern_return quadPattern() throws RecognitionException {
 7479  0
         SparqlT.quadPattern_return retval = new SparqlT.quadPattern_return();
 7480  0
         retval.start = input.LT(1);
 7481  
 
 7482  
 
 7483  0
         CommonTree root_0 = null;
 7484  
 
 7485  0
         CommonTree _first_0 = null;
 7486  0
         CommonTree _last = null;
 7487  
 
 7488  0
         SparqlT.quads_return quads195 =null;
 7489  
 
 7490  
 
 7491  
 
 7492  
         try {
 7493  
             // com\\googlecode\\sparkleg\\SparqlT.g:224:5: ( quads )
 7494  
             // com\\googlecode\\sparkleg\\SparqlT.g:224:7: quads
 7495  
             {
 7496  0
             root_0 = (CommonTree)adaptor.nil();
 7497  
 
 7498  
 
 7499  0
             _last = (CommonTree)input.LT(1);
 7500  0
             pushFollow(FOLLOW_quads_in_quadPattern1474);
 7501  0
             quads195=quads();
 7502  
 
 7503  0
             state._fsp--;
 7504  
 
 7505  0
             adaptor.addChild(root_0, quads195.getTree());
 7506  
 
 7507  
 
 7508  
             }
 7509  
 
 7510  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 7511  
 
 7512  
         }
 7513  0
         catch (RecognitionException re) {
 7514  0
             reportError(re);
 7515  0
             recover(input,re);
 7516  
         }
 7517  
 
 7518  0
         finally {
 7519  
                 // do for sure before leaving
 7520  0
         }
 7521  0
         return retval;
 7522  
     }
 7523  
     // $ANTLR end "quadPattern"
 7524  
 
 7525  
 
 7526  0
     public static class quads_return extends TreeRuleReturnScope {
 7527  
         CommonTree tree;
 7528  0
         public Object getTree() { return tree; }
 7529  
     };
 7530  
 
 7531  
 
 7532  
     // $ANTLR start "quads"
 7533  
     // com\\googlecode\\sparkleg\\SparqlT.g:227:1: quads : ( triplesTemplate )? ( quadsNotTriples ( triplesTemplate )? )* ;
 7534  
     public final SparqlT.quads_return quads() throws RecognitionException {
 7535  0
         SparqlT.quads_return retval = new SparqlT.quads_return();
 7536  0
         retval.start = input.LT(1);
 7537  
 
 7538  
 
 7539  0
         CommonTree root_0 = null;
 7540  
 
 7541  0
         CommonTree _first_0 = null;
 7542  0
         CommonTree _last = null;
 7543  
 
 7544  0
         SparqlT.triplesTemplate_return triplesTemplate196 =null;
 7545  
 
 7546  0
         SparqlT.quadsNotTriples_return quadsNotTriples197 =null;
 7547  
 
 7548  0
         SparqlT.triplesTemplate_return triplesTemplate198 =null;
 7549  
 
 7550  
 
 7551  
 
 7552  
         try {
 7553  
             // com\\googlecode\\sparkleg\\SparqlT.g:228:5: ( ( triplesTemplate )? ( quadsNotTriples ( triplesTemplate )? )* )
 7554  
             // com\\googlecode\\sparkleg\\SparqlT.g:228:7: ( triplesTemplate )? ( quadsNotTriples ( triplesTemplate )? )*
 7555  
             {
 7556  0
             root_0 = (CommonTree)adaptor.nil();
 7557  
 
 7558  
 
 7559  
             // com\\googlecode\\sparkleg\\SparqlT.g:228:7: ( triplesTemplate )?
 7560  0
             int alt78=2;
 7561  0
             switch ( input.LA(1) ) {
 7562  
                 case TRIPLES_TEMPLATE:
 7563  
                     {
 7564  0
                     alt78=1;
 7565  
                     }
 7566  
                     break;
 7567  
             }
 7568  
 
 7569  0
             switch (alt78) {
 7570  
                 case 1 :
 7571  
                     // com\\googlecode\\sparkleg\\SparqlT.g:228:7: triplesTemplate
 7572  
                     {
 7573  0
                     _last = (CommonTree)input.LT(1);
 7574  0
                     pushFollow(FOLLOW_triplesTemplate_in_quads1495);
 7575  0
                     triplesTemplate196=triplesTemplate();
 7576  
 
 7577  0
                     state._fsp--;
 7578  
 
 7579  0
                     adaptor.addChild(root_0, triplesTemplate196.getTree());
 7580  
 
 7581  
 
 7582  
                     }
 7583  
                     break;
 7584  
 
 7585  
             }
 7586  
 
 7587  
 
 7588  
             // com\\googlecode\\sparkleg\\SparqlT.g:228:24: ( quadsNotTriples ( triplesTemplate )? )*
 7589  
             loop80:
 7590  
             do {
 7591  0
                 int alt80=2;
 7592  0
                 switch ( input.LA(1) ) {
 7593  
                 case GRAPH:
 7594  
                     {
 7595  0
                     alt80=1;
 7596  
                     }
 7597  
                     break;
 7598  
 
 7599  
                 }
 7600  
 
 7601  0
                 switch (alt80) {
 7602  
                     case 1 :
 7603  
                         // com\\googlecode\\sparkleg\\SparqlT.g:228:25: quadsNotTriples ( triplesTemplate )?
 7604  
                         {
 7605  0
                         _last = (CommonTree)input.LT(1);
 7606  0
                         pushFollow(FOLLOW_quadsNotTriples_in_quads1499);
 7607  0
                         quadsNotTriples197=quadsNotTriples();
 7608  
 
 7609  0
                         state._fsp--;
 7610  
 
 7611  0
                         adaptor.addChild(root_0, quadsNotTriples197.getTree());
 7612  
 
 7613  
 
 7614  
                         // com\\googlecode\\sparkleg\\SparqlT.g:228:41: ( triplesTemplate )?
 7615  0
                         int alt79=2;
 7616  0
                         switch ( input.LA(1) ) {
 7617  
                             case TRIPLES_TEMPLATE:
 7618  
                                 {
 7619  0
                                 alt79=1;
 7620  
                                 }
 7621  
                                 break;
 7622  
                         }
 7623  
 
 7624  0
                         switch (alt79) {
 7625  
                             case 1 :
 7626  
                                 // com\\googlecode\\sparkleg\\SparqlT.g:228:41: triplesTemplate
 7627  
                                 {
 7628  0
                                 _last = (CommonTree)input.LT(1);
 7629  0
                                 pushFollow(FOLLOW_triplesTemplate_in_quads1501);
 7630  0
                                 triplesTemplate198=triplesTemplate();
 7631  
 
 7632  0
                                 state._fsp--;
 7633  
 
 7634  0
                                 adaptor.addChild(root_0, triplesTemplate198.getTree());
 7635  
 
 7636  
 
 7637  
                                 }
 7638  
                                 break;
 7639  
 
 7640  
                         }
 7641  
 
 7642  
 
 7643  
                         }
 7644  0
                         break;
 7645  
 
 7646  
                     default :
 7647  0
                         break loop80;
 7648  
                 }
 7649  0
             } while (true);
 7650  
 
 7651  
 
 7652  
             }
 7653  
 
 7654  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 7655  
 
 7656  
         }
 7657  0
         catch (RecognitionException re) {
 7658  0
             reportError(re);
 7659  0
             recover(input,re);
 7660  
         }
 7661  
 
 7662  0
         finally {
 7663  
                 // do for sure before leaving
 7664  0
         }
 7665  0
         return retval;
 7666  
     }
 7667  
     // $ANTLR end "quads"
 7668  
 
 7669  
 
 7670  0
     public static class quadsNotTriples_return extends TreeRuleReturnScope {
 7671  
         CommonTree tree;
 7672  0
         public Object getTree() { return tree; }
 7673  
     };
 7674  
 
 7675  
 
 7676  
     // $ANTLR start "quadsNotTriples"
 7677  
     // com\\googlecode\\sparkleg\\SparqlT.g:231:1: quadsNotTriples : ^( GRAPH varOrIRIref ( triplesTemplate )? ) ;
 7678  
     public final SparqlT.quadsNotTriples_return quadsNotTriples() throws RecognitionException {
 7679  0
         SparqlT.quadsNotTriples_return retval = new SparqlT.quadsNotTriples_return();
 7680  0
         retval.start = input.LT(1);
 7681  
 
 7682  
 
 7683  0
         CommonTree root_0 = null;
 7684  
 
 7685  0
         CommonTree _first_0 = null;
 7686  0
         CommonTree _last = null;
 7687  
 
 7688  0
         CommonTree GRAPH199=null;
 7689  0
         SparqlT.varOrIRIref_return varOrIRIref200 =null;
 7690  
 
 7691  0
         SparqlT.triplesTemplate_return triplesTemplate201 =null;
 7692  
 
 7693  
 
 7694  0
         CommonTree GRAPH199_tree=null;
 7695  
 
 7696  
         try {
 7697  
             // com\\googlecode\\sparkleg\\SparqlT.g:232:5: ( ^( GRAPH varOrIRIref ( triplesTemplate )? ) )
 7698  
             // com\\googlecode\\sparkleg\\SparqlT.g:232:7: ^( GRAPH varOrIRIref ( triplesTemplate )? )
 7699  
             {
 7700  0
             root_0 = (CommonTree)adaptor.nil();
 7701  
 
 7702  
 
 7703  0
             _last = (CommonTree)input.LT(1);
 7704  
             {
 7705  0
             CommonTree _save_last_1 = _last;
 7706  0
             CommonTree _first_1 = null;
 7707  0
             CommonTree root_1 = (CommonTree)adaptor.nil();
 7708  0
             _last = (CommonTree)input.LT(1);
 7709  0
             GRAPH199=(CommonTree)match(input,GRAPH,FOLLOW_GRAPH_in_quadsNotTriples1526); 
 7710  0
             GRAPH199_tree = (CommonTree)adaptor.dupNode(GRAPH199);
 7711  
 
 7712  
 
 7713  0
             root_1 = (CommonTree)adaptor.becomeRoot(GRAPH199_tree, root_1);
 7714  
 
 7715  
 
 7716  0
             match(input, Token.DOWN, null); 
 7717  0
             _last = (CommonTree)input.LT(1);
 7718  0
             pushFollow(FOLLOW_varOrIRIref_in_quadsNotTriples1528);
 7719  0
             varOrIRIref200=varOrIRIref();
 7720  
 
 7721  0
             state._fsp--;
 7722  
 
 7723  0
             adaptor.addChild(root_1, varOrIRIref200.getTree());
 7724  
 
 7725  
 
 7726  
             // com\\googlecode\\sparkleg\\SparqlT.g:232:27: ( triplesTemplate )?
 7727  0
             int alt81=2;
 7728  0
             switch ( input.LA(1) ) {
 7729  
                 case TRIPLES_TEMPLATE:
 7730  
                     {
 7731  0
                     alt81=1;
 7732  
                     }
 7733  
                     break;
 7734  
             }
 7735  
 
 7736  0
             switch (alt81) {
 7737  
                 case 1 :
 7738  
                     // com\\googlecode\\sparkleg\\SparqlT.g:232:27: triplesTemplate
 7739  
                     {
 7740  0
                     _last = (CommonTree)input.LT(1);
 7741  0
                     pushFollow(FOLLOW_triplesTemplate_in_quadsNotTriples1530);
 7742  0
                     triplesTemplate201=triplesTemplate();
 7743  
 
 7744  0
                     state._fsp--;
 7745  
 
 7746  0
                     adaptor.addChild(root_1, triplesTemplate201.getTree());
 7747  
 
 7748  
 
 7749  
                     }
 7750  
                     break;
 7751  
 
 7752  
             }
 7753  
 
 7754  
 
 7755  0
             match(input, Token.UP, null); 
 7756  0
             adaptor.addChild(root_0, root_1);
 7757  0
             _last = _save_last_1;
 7758  
             }
 7759  
 
 7760  
 
 7761  
             }
 7762  
 
 7763  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 7764  
 
 7765  
         }
 7766  0
         catch (RecognitionException re) {
 7767  0
             reportError(re);
 7768  0
             recover(input,re);
 7769  
         }
 7770  
 
 7771  0
         finally {
 7772  
                 // do for sure before leaving
 7773  0
         }
 7774  0
         return retval;
 7775  
     }
 7776  
     // $ANTLR end "quadsNotTriples"
 7777  
 
 7778  
 
 7779  0
     public static class triplesTemplate_return extends TreeRuleReturnScope {
 7780  
         CommonTree tree;
 7781  0
         public Object getTree() { return tree; }
 7782  
     };
 7783  
 
 7784  
 
 7785  
     // $ANTLR start "triplesTemplate"
 7786  
     // com\\googlecode\\sparkleg\\SparqlT.g:235:1: triplesTemplate : ^( TRIPLES_TEMPLATE ( triplesSameSubject )* ) ;
 7787  
     public final SparqlT.triplesTemplate_return triplesTemplate() throws RecognitionException {
 7788  0
         SparqlT.triplesTemplate_return retval = new SparqlT.triplesTemplate_return();
 7789  0
         retval.start = input.LT(1);
 7790  
 
 7791  
 
 7792  0
         CommonTree root_0 = null;
 7793  
 
 7794  0
         CommonTree _first_0 = null;
 7795  0
         CommonTree _last = null;
 7796  
 
 7797  0
         CommonTree TRIPLES_TEMPLATE202=null;
 7798  0
         SparqlT.triplesSameSubject_return triplesSameSubject203 =null;
 7799  
 
 7800  
 
 7801  0
         CommonTree TRIPLES_TEMPLATE202_tree=null;
 7802  
 
 7803  
         try {
 7804  
             // com\\googlecode\\sparkleg\\SparqlT.g:236:5: ( ^( TRIPLES_TEMPLATE ( triplesSameSubject )* ) )
 7805  
             // com\\googlecode\\sparkleg\\SparqlT.g:236:7: ^( TRIPLES_TEMPLATE ( triplesSameSubject )* )
 7806  
             {
 7807  0
             root_0 = (CommonTree)adaptor.nil();
 7808  
 
 7809  
 
 7810  0
             _last = (CommonTree)input.LT(1);
 7811  
             {
 7812  0
             CommonTree _save_last_1 = _last;
 7813  0
             CommonTree _first_1 = null;
 7814  0
             CommonTree root_1 = (CommonTree)adaptor.nil();
 7815  0
             _last = (CommonTree)input.LT(1);
 7816  0
             TRIPLES_TEMPLATE202=(CommonTree)match(input,TRIPLES_TEMPLATE,FOLLOW_TRIPLES_TEMPLATE_in_triplesTemplate1554); 
 7817  0
             TRIPLES_TEMPLATE202_tree = (CommonTree)adaptor.dupNode(TRIPLES_TEMPLATE202);
 7818  
 
 7819  
 
 7820  0
             root_1 = (CommonTree)adaptor.becomeRoot(TRIPLES_TEMPLATE202_tree, root_1);
 7821  
 
 7822  
 
 7823  0
             if ( input.LA(1)==Token.DOWN ) {
 7824  0
                 match(input, Token.DOWN, null); 
 7825  
                 // com\\googlecode\\sparkleg\\SparqlT.g:236:26: ( triplesSameSubject )*
 7826  
                 loop82:
 7827  
                 do {
 7828  0
                     int alt82=2;
 7829  0
                     switch ( input.LA(1) ) {
 7830  
                     case TRIPLES_SAME_SUBJECT:
 7831  
                         {
 7832  0
                         alt82=1;
 7833  
                         }
 7834  
                         break;
 7835  
 
 7836  
                     }
 7837  
 
 7838  0
                     switch (alt82) {
 7839  
                         case 1 :
 7840  
                             // com\\googlecode\\sparkleg\\SparqlT.g:236:26: triplesSameSubject
 7841  
                             {
 7842  0
                             _last = (CommonTree)input.LT(1);
 7843  0
                             pushFollow(FOLLOW_triplesSameSubject_in_triplesTemplate1556);
 7844  0
                             triplesSameSubject203=triplesSameSubject();
 7845  
 
 7846  0
                             state._fsp--;
 7847  
 
 7848  0
                             adaptor.addChild(root_1, triplesSameSubject203.getTree());
 7849  
 
 7850  
 
 7851  
                             }
 7852  0
                             break;
 7853  
 
 7854  
                         default :
 7855  0
                             break loop82;
 7856  
                     }
 7857  0
                 } while (true);
 7858  
 
 7859  
 
 7860  0
                 match(input, Token.UP, null); 
 7861  
             }
 7862  0
             adaptor.addChild(root_0, root_1);
 7863  0
             _last = _save_last_1;
 7864  
             }
 7865  
 
 7866  
 
 7867  
             }
 7868  
 
 7869  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 7870  
 
 7871  
         }
 7872  0
         catch (RecognitionException re) {
 7873  0
             reportError(re);
 7874  0
             recover(input,re);
 7875  
         }
 7876  
 
 7877  0
         finally {
 7878  
                 // do for sure before leaving
 7879  0
         }
 7880  0
         return retval;
 7881  
     }
 7882  
     // $ANTLR end "triplesTemplate"
 7883  
 
 7884  
 
 7885  0
     public static class groupGraphPattern_return extends TreeRuleReturnScope {
 7886  
         CommonTree tree;
 7887  0
         public Object getTree() { return tree; }
 7888  
     };
 7889  
 
 7890  
 
 7891  
     // $ANTLR start "groupGraphPattern"
 7892  
     // com\\googlecode\\sparkleg\\SparqlT.g:239:1: groupGraphPattern : ( ^( GROUP_GRAPH_PATTERN groupGraphPatternSub ) | ^( GROUP_GRAPH_PATTERN subSelect ) | ^( GROUP_GRAPH_PATTERN GROUP_GRAPH_PATTERN ) );
 7893  
     public final SparqlT.groupGraphPattern_return groupGraphPattern() throws RecognitionException {
 7894  0
         SparqlT.groupGraphPattern_return retval = new SparqlT.groupGraphPattern_return();
 7895  0
         retval.start = input.LT(1);
 7896  
 
 7897  
 
 7898  0
         CommonTree root_0 = null;
 7899  
 
 7900  0
         CommonTree _first_0 = null;
 7901  0
         CommonTree _last = null;
 7902  
 
 7903  0
         CommonTree GROUP_GRAPH_PATTERN204=null;
 7904  0
         CommonTree GROUP_GRAPH_PATTERN206=null;
 7905  0
         CommonTree GROUP_GRAPH_PATTERN208=null;
 7906  0
         CommonTree GROUP_GRAPH_PATTERN209=null;
 7907  0
         SparqlT.groupGraphPatternSub_return groupGraphPatternSub205 =null;
 7908  
 
 7909  0
         SparqlT.subSelect_return subSelect207 =null;
 7910  
 
 7911  
 
 7912  0
         CommonTree GROUP_GRAPH_PATTERN204_tree=null;
 7913  0
         CommonTree GROUP_GRAPH_PATTERN206_tree=null;
 7914  0
         CommonTree GROUP_GRAPH_PATTERN208_tree=null;
 7915  0
         CommonTree GROUP_GRAPH_PATTERN209_tree=null;
 7916  
 
 7917  
         try {
 7918  
             // com\\googlecode\\sparkleg\\SparqlT.g:240:5: ( ^( GROUP_GRAPH_PATTERN groupGraphPatternSub ) | ^( GROUP_GRAPH_PATTERN subSelect ) | ^( GROUP_GRAPH_PATTERN GROUP_GRAPH_PATTERN ) )
 7919  0
             int alt83=3;
 7920  0
             switch ( input.LA(1) ) {
 7921  
             case GROUP_GRAPH_PATTERN:
 7922  
                 {
 7923  0
                 switch ( input.LA(2) ) {
 7924  
                 case DOWN:
 7925  
                     {
 7926  0
                     switch ( input.LA(3) ) {
 7927  
                     case GROUP_GRAPH_PATTERN:
 7928  
                         {
 7929  0
                         switch ( input.LA(4) ) {
 7930  
                         case UP:
 7931  
                             {
 7932  0
                             alt83=3;
 7933  
                             }
 7934  0
                             break;
 7935  
                         case DOWN:
 7936  
                             {
 7937  0
                             alt83=1;
 7938  
                             }
 7939  0
                             break;
 7940  
                         default:
 7941  0
                             NoViableAltException nvae =
 7942  
                                 new NoViableAltException("", 83, 3, input);
 7943  
 
 7944  0
                             throw nvae;
 7945  
 
 7946  
                         }
 7947  
 
 7948  
                         }
 7949  0
                         break;
 7950  
                     case BIND:
 7951  
                     case FILTER:
 7952  
                     case GRAPH:
 7953  
                     case MINUS_KEYWORD:
 7954  
                     case OPTIONAL:
 7955  
                     case SERVICE:
 7956  
                     case TRIPLES_SAME_SUBJECT:
 7957  
                     case UNION:
 7958  
                         {
 7959  0
                         alt83=1;
 7960  
                         }
 7961  0
                         break;
 7962  
                     case SUBSELECT:
 7963  
                         {
 7964  0
                         alt83=2;
 7965  
                         }
 7966  0
                         break;
 7967  
                     default:
 7968  0
                         NoViableAltException nvae =
 7969  
                             new NoViableAltException("", 83, 2, input);
 7970  
 
 7971  0
                         throw nvae;
 7972  
 
 7973  
                     }
 7974  
 
 7975  
                     }
 7976  0
                     break;
 7977  
                 default:
 7978  0
                     NoViableAltException nvae =
 7979  
                         new NoViableAltException("", 83, 1, input);
 7980  
 
 7981  0
                     throw nvae;
 7982  
 
 7983  
                 }
 7984  
 
 7985  
                 }
 7986  0
                 break;
 7987  
             default:
 7988  0
                 NoViableAltException nvae =
 7989  
                     new NoViableAltException("", 83, 0, input);
 7990  
 
 7991  0
                 throw nvae;
 7992  
 
 7993  
             }
 7994  
 
 7995  0
             switch (alt83) {
 7996  
                 case 1 :
 7997  
                     // com\\googlecode\\sparkleg\\SparqlT.g:240:7: ^( GROUP_GRAPH_PATTERN groupGraphPatternSub )
 7998  
                     {
 7999  0
                     root_0 = (CommonTree)adaptor.nil();
 8000  
 
 8001  
 
 8002  0
                     _last = (CommonTree)input.LT(1);
 8003  
                     {
 8004  0
                     CommonTree _save_last_1 = _last;
 8005  0
                     CommonTree _first_1 = null;
 8006  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 8007  0
                     _last = (CommonTree)input.LT(1);
 8008  0
                     GROUP_GRAPH_PATTERN204=(CommonTree)match(input,GROUP_GRAPH_PATTERN,FOLLOW_GROUP_GRAPH_PATTERN_in_groupGraphPattern1576); 
 8009  0
                     GROUP_GRAPH_PATTERN204_tree = (CommonTree)adaptor.dupNode(GROUP_GRAPH_PATTERN204);
 8010  
 
 8011  
 
 8012  0
                     root_1 = (CommonTree)adaptor.becomeRoot(GROUP_GRAPH_PATTERN204_tree, root_1);
 8013  
 
 8014  
 
 8015  0
                     match(input, Token.DOWN, null); 
 8016  0
                     _last = (CommonTree)input.LT(1);
 8017  0
                     pushFollow(FOLLOW_groupGraphPatternSub_in_groupGraphPattern1578);
 8018  0
                     groupGraphPatternSub205=groupGraphPatternSub();
 8019  
 
 8020  0
                     state._fsp--;
 8021  
 
 8022  0
                     adaptor.addChild(root_1, groupGraphPatternSub205.getTree());
 8023  
 
 8024  
 
 8025  0
                     match(input, Token.UP, null); 
 8026  0
                     adaptor.addChild(root_0, root_1);
 8027  0
                     _last = _save_last_1;
 8028  
                     }
 8029  
 
 8030  
 
 8031  
                     }
 8032  0
                     break;
 8033  
                 case 2 :
 8034  
                     // com\\googlecode\\sparkleg\\SparqlT.g:241:7: ^( GROUP_GRAPH_PATTERN subSelect )
 8035  
                     {
 8036  0
                     root_0 = (CommonTree)adaptor.nil();
 8037  
 
 8038  
 
 8039  0
                     _last = (CommonTree)input.LT(1);
 8040  
                     {
 8041  0
                     CommonTree _save_last_1 = _last;
 8042  0
                     CommonTree _first_1 = null;
 8043  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 8044  0
                     _last = (CommonTree)input.LT(1);
 8045  0
                     GROUP_GRAPH_PATTERN206=(CommonTree)match(input,GROUP_GRAPH_PATTERN,FOLLOW_GROUP_GRAPH_PATTERN_in_groupGraphPattern1588); 
 8046  0
                     GROUP_GRAPH_PATTERN206_tree = (CommonTree)adaptor.dupNode(GROUP_GRAPH_PATTERN206);
 8047  
 
 8048  
 
 8049  0
                     root_1 = (CommonTree)adaptor.becomeRoot(GROUP_GRAPH_PATTERN206_tree, root_1);
 8050  
 
 8051  
 
 8052  0
                     match(input, Token.DOWN, null); 
 8053  0
                     _last = (CommonTree)input.LT(1);
 8054  0
                     pushFollow(FOLLOW_subSelect_in_groupGraphPattern1590);
 8055  0
                     subSelect207=subSelect();
 8056  
 
 8057  0
                     state._fsp--;
 8058  
 
 8059  0
                     adaptor.addChild(root_1, subSelect207.getTree());
 8060  
 
 8061  
 
 8062  0
                     match(input, Token.UP, null); 
 8063  0
                     adaptor.addChild(root_0, root_1);
 8064  0
                     _last = _save_last_1;
 8065  
                     }
 8066  
 
 8067  
 
 8068  
                     }
 8069  0
                     break;
 8070  
                 case 3 :
 8071  
                     // com\\googlecode\\sparkleg\\SparqlT.g:242:7: ^( GROUP_GRAPH_PATTERN GROUP_GRAPH_PATTERN )
 8072  
                     {
 8073  0
                     root_0 = (CommonTree)adaptor.nil();
 8074  
 
 8075  
 
 8076  0
                     _last = (CommonTree)input.LT(1);
 8077  
                     {
 8078  0
                     CommonTree _save_last_1 = _last;
 8079  0
                     CommonTree _first_1 = null;
 8080  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 8081  0
                     _last = (CommonTree)input.LT(1);
 8082  0
                     GROUP_GRAPH_PATTERN208=(CommonTree)match(input,GROUP_GRAPH_PATTERN,FOLLOW_GROUP_GRAPH_PATTERN_in_groupGraphPattern1600); 
 8083  0
                     GROUP_GRAPH_PATTERN208_tree = (CommonTree)adaptor.dupNode(GROUP_GRAPH_PATTERN208);
 8084  
 
 8085  
 
 8086  0
                     root_1 = (CommonTree)adaptor.becomeRoot(GROUP_GRAPH_PATTERN208_tree, root_1);
 8087  
 
 8088  
 
 8089  0
                     match(input, Token.DOWN, null); 
 8090  0
                     _last = (CommonTree)input.LT(1);
 8091  0
                     GROUP_GRAPH_PATTERN209=(CommonTree)match(input,GROUP_GRAPH_PATTERN,FOLLOW_GROUP_GRAPH_PATTERN_in_groupGraphPattern1602); 
 8092  0
                     GROUP_GRAPH_PATTERN209_tree = (CommonTree)adaptor.dupNode(GROUP_GRAPH_PATTERN209);
 8093  
 
 8094  
 
 8095  0
                     adaptor.addChild(root_1, GROUP_GRAPH_PATTERN209_tree);
 8096  
 
 8097  
 
 8098  0
                     match(input, Token.UP, null); 
 8099  0
                     adaptor.addChild(root_0, root_1);
 8100  0
                     _last = _save_last_1;
 8101  
                     }
 8102  
 
 8103  
 
 8104  
                     }
 8105  
                     break;
 8106  
 
 8107  
             }
 8108  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 8109  
 
 8110  
         }
 8111  0
         catch (RecognitionException re) {
 8112  0
             reportError(re);
 8113  0
             recover(input,re);
 8114  
         }
 8115  
 
 8116  0
         finally {
 8117  
                 // do for sure before leaving
 8118  0
         }
 8119  0
         return retval;
 8120  
     }
 8121  
     // $ANTLR end "groupGraphPattern"
 8122  
 
 8123  
 
 8124  0
     public static class groupGraphPatternSub_return extends TreeRuleReturnScope {
 8125  
         CommonTree tree;
 8126  0
         public Object getTree() { return tree; }
 8127  
     };
 8128  
 
 8129  
 
 8130  
     // $ANTLR start "groupGraphPatternSub"
 8131  
     // com\\googlecode\\sparkleg\\SparqlT.g:245:1: groupGraphPatternSub : ( triplesBlock ( groupGraphPatternSubDetail )* | ( groupGraphPatternSubDetail )+ );
 8132  
     public final SparqlT.groupGraphPatternSub_return groupGraphPatternSub() throws RecognitionException {
 8133  0
         SparqlT.groupGraphPatternSub_return retval = new SparqlT.groupGraphPatternSub_return();
 8134  0
         retval.start = input.LT(1);
 8135  
 
 8136  
 
 8137  0
         CommonTree root_0 = null;
 8138  
 
 8139  0
         CommonTree _first_0 = null;
 8140  0
         CommonTree _last = null;
 8141  
 
 8142  0
         SparqlT.triplesBlock_return triplesBlock210 =null;
 8143  
 
 8144  0
         SparqlT.groupGraphPatternSubDetail_return groupGraphPatternSubDetail211 =null;
 8145  
 
 8146  0
         SparqlT.groupGraphPatternSubDetail_return groupGraphPatternSubDetail212 =null;
 8147  
 
 8148  
 
 8149  
 
 8150  
         try {
 8151  
             // com\\googlecode\\sparkleg\\SparqlT.g:246:5: ( triplesBlock ( groupGraphPatternSubDetail )* | ( groupGraphPatternSubDetail )+ )
 8152  0
             int alt86=2;
 8153  0
             switch ( input.LA(1) ) {
 8154  
             case TRIPLES_SAME_SUBJECT:
 8155  
                 {
 8156  0
                 alt86=1;
 8157  
                 }
 8158  0
                 break;
 8159  
             case BIND:
 8160  
             case FILTER:
 8161  
             case GRAPH:
 8162  
             case GROUP_GRAPH_PATTERN:
 8163  
             case MINUS_KEYWORD:
 8164  
             case OPTIONAL:
 8165  
             case SERVICE:
 8166  
             case UNION:
 8167  
                 {
 8168  0
                 alt86=2;
 8169  
                 }
 8170  0
                 break;
 8171  
             default:
 8172  0
                 NoViableAltException nvae =
 8173  
                     new NoViableAltException("", 86, 0, input);
 8174  
 
 8175  0
                 throw nvae;
 8176  
 
 8177  
             }
 8178  
 
 8179  0
             switch (alt86) {
 8180  
                 case 1 :
 8181  
                     // com\\googlecode\\sparkleg\\SparqlT.g:246:7: triplesBlock ( groupGraphPatternSubDetail )*
 8182  
                     {
 8183  0
                     root_0 = (CommonTree)adaptor.nil();
 8184  
 
 8185  
 
 8186  0
                     _last = (CommonTree)input.LT(1);
 8187  0
                     pushFollow(FOLLOW_triplesBlock_in_groupGraphPatternSub1620);
 8188  0
                     triplesBlock210=triplesBlock();
 8189  
 
 8190  0
                     state._fsp--;
 8191  
 
 8192  0
                     adaptor.addChild(root_0, triplesBlock210.getTree());
 8193  
 
 8194  
 
 8195  
                     // com\\googlecode\\sparkleg\\SparqlT.g:246:20: ( groupGraphPatternSubDetail )*
 8196  
                     loop84:
 8197  
                     do {
 8198  0
                         int alt84=2;
 8199  0
                         switch ( input.LA(1) ) {
 8200  
                         case BIND:
 8201  
                         case FILTER:
 8202  
                         case GRAPH:
 8203  
                         case GROUP_GRAPH_PATTERN:
 8204  
                         case MINUS_KEYWORD:
 8205  
                         case OPTIONAL:
 8206  
                         case SERVICE:
 8207  
                         case UNION:
 8208  
                             {
 8209  0
                             alt84=1;
 8210  
                             }
 8211  
                             break;
 8212  
 
 8213  
                         }
 8214  
 
 8215  0
                         switch (alt84) {
 8216  
                             case 1 :
 8217  
                                 // com\\googlecode\\sparkleg\\SparqlT.g:246:20: groupGraphPatternSubDetail
 8218  
                                 {
 8219  0
                                 _last = (CommonTree)input.LT(1);
 8220  0
                                 pushFollow(FOLLOW_groupGraphPatternSubDetail_in_groupGraphPatternSub1622);
 8221  0
                                 groupGraphPatternSubDetail211=groupGraphPatternSubDetail();
 8222  
 
 8223  0
                                 state._fsp--;
 8224  
 
 8225  0
                                 adaptor.addChild(root_0, groupGraphPatternSubDetail211.getTree());
 8226  
 
 8227  
 
 8228  
                                 }
 8229  0
                                 break;
 8230  
 
 8231  
                             default :
 8232  0
                                 break loop84;
 8233  
                         }
 8234  0
                     } while (true);
 8235  
 
 8236  
 
 8237  
                     }
 8238  
                     break;
 8239  
                 case 2 :
 8240  
                     // com\\googlecode\\sparkleg\\SparqlT.g:247:7: ( groupGraphPatternSubDetail )+
 8241  
                     {
 8242  0
                     root_0 = (CommonTree)adaptor.nil();
 8243  
 
 8244  
 
 8245  
                     // com\\googlecode\\sparkleg\\SparqlT.g:247:7: ( groupGraphPatternSubDetail )+
 8246  0
                     int cnt85=0;
 8247  
                     loop85:
 8248  
                     do {
 8249  0
                         int alt85=2;
 8250  0
                         switch ( input.LA(1) ) {
 8251  
                         case BIND:
 8252  
                         case FILTER:
 8253  
                         case GRAPH:
 8254  
                         case GROUP_GRAPH_PATTERN:
 8255  
                         case MINUS_KEYWORD:
 8256  
                         case OPTIONAL:
 8257  
                         case SERVICE:
 8258  
                         case UNION:
 8259  
                             {
 8260  0
                             alt85=1;
 8261  
                             }
 8262  
                             break;
 8263  
 
 8264  
                         }
 8265  
 
 8266  0
                         switch (alt85) {
 8267  
                             case 1 :
 8268  
                                 // com\\googlecode\\sparkleg\\SparqlT.g:247:7: groupGraphPatternSubDetail
 8269  
                                 {
 8270  0
                                 _last = (CommonTree)input.LT(1);
 8271  0
                                 pushFollow(FOLLOW_groupGraphPatternSubDetail_in_groupGraphPatternSub1631);
 8272  0
                                 groupGraphPatternSubDetail212=groupGraphPatternSubDetail();
 8273  
 
 8274  0
                                 state._fsp--;
 8275  
 
 8276  0
                                 adaptor.addChild(root_0, groupGraphPatternSubDetail212.getTree());
 8277  
 
 8278  
 
 8279  
                                 }
 8280  0
                                 break;
 8281  
 
 8282  
                             default :
 8283  0
                                 if ( cnt85 >= 1 ) break loop85;
 8284  0
                                 EarlyExitException eee =
 8285  
                                     new EarlyExitException(85, input);
 8286  0
                                 throw eee;
 8287  
                         }
 8288  0
                         cnt85++;
 8289  0
                     } while (true);
 8290  
 
 8291  
 
 8292  
                     }
 8293  
                     break;
 8294  
 
 8295  
             }
 8296  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 8297  
 
 8298  
         }
 8299  0
         catch (RecognitionException re) {
 8300  0
             reportError(re);
 8301  0
             recover(input,re);
 8302  
         }
 8303  
 
 8304  0
         finally {
 8305  
                 // do for sure before leaving
 8306  0
         }
 8307  0
         return retval;
 8308  
     }
 8309  
     // $ANTLR end "groupGraphPatternSub"
 8310  
 
 8311  
 
 8312  0
     public static class groupGraphPatternSubDetail_return extends TreeRuleReturnScope {
 8313  
         CommonTree tree;
 8314  0
         public Object getTree() { return tree; }
 8315  
     };
 8316  
 
 8317  
 
 8318  
     // $ANTLR start "groupGraphPatternSubDetail"
 8319  
     // com\\googlecode\\sparkleg\\SparqlT.g:250:1: groupGraphPatternSubDetail : g= graphPatternNotTriples ( DOT )? (t= triplesBlock )? ;
 8320  
     public final SparqlT.groupGraphPatternSubDetail_return groupGraphPatternSubDetail() throws RecognitionException {
 8321  0
         SparqlT.groupGraphPatternSubDetail_return retval = new SparqlT.groupGraphPatternSubDetail_return();
 8322  0
         retval.start = input.LT(1);
 8323  
 
 8324  
 
 8325  0
         CommonTree root_0 = null;
 8326  
 
 8327  0
         CommonTree _first_0 = null;
 8328  0
         CommonTree _last = null;
 8329  
 
 8330  0
         CommonTree DOT213=null;
 8331  0
         SparqlT.graphPatternNotTriples_return g =null;
 8332  
 
 8333  0
         SparqlT.triplesBlock_return t =null;
 8334  
 
 8335  
 
 8336  0
         CommonTree DOT213_tree=null;
 8337  
 
 8338  
         try {
 8339  
             // com\\googlecode\\sparkleg\\SparqlT.g:251:5: (g= graphPatternNotTriples ( DOT )? (t= triplesBlock )? )
 8340  
             // com\\googlecode\\sparkleg\\SparqlT.g:251:7: g= graphPatternNotTriples ( DOT )? (t= triplesBlock )?
 8341  
             {
 8342  0
             root_0 = (CommonTree)adaptor.nil();
 8343  
 
 8344  
 
 8345  0
             _last = (CommonTree)input.LT(1);
 8346  0
             pushFollow(FOLLOW_graphPatternNotTriples_in_groupGraphPatternSubDetail1652);
 8347  0
             g=graphPatternNotTriples();
 8348  
 
 8349  0
             state._fsp--;
 8350  
 
 8351  0
             adaptor.addChild(root_0, g.getTree());
 8352  
 
 8353  
 
 8354  
             // com\\googlecode\\sparkleg\\SparqlT.g:251:32: ( DOT )?
 8355  0
             int alt87=2;
 8356  0
             switch ( input.LA(1) ) {
 8357  
                 case DOT:
 8358  
                     {
 8359  0
                     alt87=1;
 8360  
                     }
 8361  
                     break;
 8362  
             }
 8363  
 
 8364  0
             switch (alt87) {
 8365  
                 case 1 :
 8366  
                     // com\\googlecode\\sparkleg\\SparqlT.g:251:32: DOT
 8367  
                     {
 8368  0
                     _last = (CommonTree)input.LT(1);
 8369  0
                     DOT213=(CommonTree)match(input,DOT,FOLLOW_DOT_in_groupGraphPatternSubDetail1654); 
 8370  0
                     DOT213_tree = (CommonTree)adaptor.dupNode(DOT213);
 8371  
 
 8372  
 
 8373  0
                     adaptor.addChild(root_0, DOT213_tree);
 8374  
 
 8375  
 
 8376  
                     }
 8377  
                     break;
 8378  
 
 8379  
             }
 8380  
 
 8381  
 
 8382  
             // com\\googlecode\\sparkleg\\SparqlT.g:251:38: (t= triplesBlock )?
 8383  0
             int alt88=2;
 8384  0
             switch ( input.LA(1) ) {
 8385  
                 case TRIPLES_SAME_SUBJECT:
 8386  
                     {
 8387  0
                     alt88=1;
 8388  
                     }
 8389  
                     break;
 8390  
             }
 8391  
 
 8392  0
             switch (alt88) {
 8393  
                 case 1 :
 8394  
                     // com\\googlecode\\sparkleg\\SparqlT.g:251:38: t= triplesBlock
 8395  
                     {
 8396  0
                     _last = (CommonTree)input.LT(1);
 8397  0
                     pushFollow(FOLLOW_triplesBlock_in_groupGraphPatternSubDetail1659);
 8398  0
                     t=triplesBlock();
 8399  
 
 8400  0
                     state._fsp--;
 8401  
 
 8402  0
                     adaptor.addChild(root_0, t.getTree());
 8403  
 
 8404  
 
 8405  
                     }
 8406  
                     break;
 8407  
 
 8408  
             }
 8409  
 
 8410  
 
 8411  
             }
 8412  
 
 8413  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 8414  
 
 8415  
         }
 8416  0
         catch (RecognitionException re) {
 8417  0
             reportError(re);
 8418  0
             recover(input,re);
 8419  
         }
 8420  
 
 8421  0
         finally {
 8422  
                 // do for sure before leaving
 8423  0
         }
 8424  0
         return retval;
 8425  
     }
 8426  
     // $ANTLR end "groupGraphPatternSubDetail"
 8427  
 
 8428  
 
 8429  0
     public static class triplesBlock_return extends TreeRuleReturnScope {
 8430  
         CommonTree tree;
 8431  0
         public Object getTree() { return tree; }
 8432  
     };
 8433  
 
 8434  
 
 8435  
     // $ANTLR start "triplesBlock"
 8436  
     // com\\googlecode\\sparkleg\\SparqlT.g:254:1: triplesBlock : ( triplesSameSubjectPath )+ ;
 8437  
     public final SparqlT.triplesBlock_return triplesBlock() throws RecognitionException {
 8438  0
         SparqlT.triplesBlock_return retval = new SparqlT.triplesBlock_return();
 8439  0
         retval.start = input.LT(1);
 8440  
 
 8441  
 
 8442  0
         CommonTree root_0 = null;
 8443  
 
 8444  0
         CommonTree _first_0 = null;
 8445  0
         CommonTree _last = null;
 8446  
 
 8447  0
         SparqlT.triplesSameSubjectPath_return triplesSameSubjectPath214 =null;
 8448  
 
 8449  
 
 8450  
 
 8451  
         try {
 8452  
             // com\\googlecode\\sparkleg\\SparqlT.g:255:5: ( ( triplesSameSubjectPath )+ )
 8453  
             // com\\googlecode\\sparkleg\\SparqlT.g:255:7: ( triplesSameSubjectPath )+
 8454  
             {
 8455  0
             root_0 = (CommonTree)adaptor.nil();
 8456  
 
 8457  
 
 8458  
             // com\\googlecode\\sparkleg\\SparqlT.g:255:7: ( triplesSameSubjectPath )+
 8459  0
             int cnt89=0;
 8460  
             loop89:
 8461  
             do {
 8462  0
                 int alt89=2;
 8463  0
                 switch ( input.LA(1) ) {
 8464  
                 case TRIPLES_SAME_SUBJECT:
 8465  
                     {
 8466  0
                     alt89=1;
 8467  
                     }
 8468  
                     break;
 8469  
 
 8470  
                 }
 8471  
 
 8472  0
                 switch (alt89) {
 8473  
                     case 1 :
 8474  
                         // com\\googlecode\\sparkleg\\SparqlT.g:255:7: triplesSameSubjectPath
 8475  
                         {
 8476  0
                         _last = (CommonTree)input.LT(1);
 8477  0
                         pushFollow(FOLLOW_triplesSameSubjectPath_in_triplesBlock1681);
 8478  0
                         triplesSameSubjectPath214=triplesSameSubjectPath();
 8479  
 
 8480  0
                         state._fsp--;
 8481  
 
 8482  0
                         adaptor.addChild(root_0, triplesSameSubjectPath214.getTree());
 8483  
 
 8484  
 
 8485  
                         }
 8486  0
                         break;
 8487  
 
 8488  
                     default :
 8489  0
                         if ( cnt89 >= 1 ) break loop89;
 8490  0
                         EarlyExitException eee =
 8491  
                             new EarlyExitException(89, input);
 8492  0
                         throw eee;
 8493  
                 }
 8494  0
                 cnt89++;
 8495  0
             } while (true);
 8496  
 
 8497  
 
 8498  
             }
 8499  
 
 8500  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 8501  
 
 8502  
         }
 8503  0
         catch (RecognitionException re) {
 8504  0
             reportError(re);
 8505  0
             recover(input,re);
 8506  
         }
 8507  
 
 8508  0
         finally {
 8509  
                 // do for sure before leaving
 8510  0
         }
 8511  0
         return retval;
 8512  
     }
 8513  
     // $ANTLR end "triplesBlock"
 8514  
 
 8515  
 
 8516  0
     public static class graphPatternNotTriples_return extends TreeRuleReturnScope {
 8517  
         CommonTree tree;
 8518  0
         public Object getTree() { return tree; }
 8519  
     };
 8520  
 
 8521  
 
 8522  
     // $ANTLR start "graphPatternNotTriples"
 8523  
     // com\\googlecode\\sparkleg\\SparqlT.g:258:1: graphPatternNotTriples : ( groupOrUnionGraphPattern | optionalGraphPattern | minusGraphPattern | graphGraphPattern | serviceGraphPattern | filter | bind );
 8524  
     public final SparqlT.graphPatternNotTriples_return graphPatternNotTriples() throws RecognitionException {
 8525  0
         SparqlT.graphPatternNotTriples_return retval = new SparqlT.graphPatternNotTriples_return();
 8526  0
         retval.start = input.LT(1);
 8527  
 
 8528  
 
 8529  0
         CommonTree root_0 = null;
 8530  
 
 8531  0
         CommonTree _first_0 = null;
 8532  0
         CommonTree _last = null;
 8533  
 
 8534  0
         SparqlT.groupOrUnionGraphPattern_return groupOrUnionGraphPattern215 =null;
 8535  
 
 8536  0
         SparqlT.optionalGraphPattern_return optionalGraphPattern216 =null;
 8537  
 
 8538  0
         SparqlT.minusGraphPattern_return minusGraphPattern217 =null;
 8539  
 
 8540  0
         SparqlT.graphGraphPattern_return graphGraphPattern218 =null;
 8541  
 
 8542  0
         SparqlT.serviceGraphPattern_return serviceGraphPattern219 =null;
 8543  
 
 8544  0
         SparqlT.filter_return filter220 =null;
 8545  
 
 8546  0
         SparqlT.bind_return bind221 =null;
 8547  
 
 8548  
 
 8549  
 
 8550  
         try {
 8551  
             // com\\googlecode\\sparkleg\\SparqlT.g:259:5: ( groupOrUnionGraphPattern | optionalGraphPattern | minusGraphPattern | graphGraphPattern | serviceGraphPattern | filter | bind )
 8552  0
             int alt90=7;
 8553  0
             switch ( input.LA(1) ) {
 8554  
             case GROUP_GRAPH_PATTERN:
 8555  
             case UNION:
 8556  
                 {
 8557  0
                 alt90=1;
 8558  
                 }
 8559  0
                 break;
 8560  
             case OPTIONAL:
 8561  
                 {
 8562  0
                 alt90=2;
 8563  
                 }
 8564  0
                 break;
 8565  
             case MINUS_KEYWORD:
 8566  
                 {
 8567  0
                 alt90=3;
 8568  
                 }
 8569  0
                 break;
 8570  
             case GRAPH:
 8571  
                 {
 8572  0
                 alt90=4;
 8573  
                 }
 8574  0
                 break;
 8575  
             case SERVICE:
 8576  
                 {
 8577  0
                 alt90=5;
 8578  
                 }
 8579  0
                 break;
 8580  
             case FILTER:
 8581  
                 {
 8582  0
                 alt90=6;
 8583  
                 }
 8584  0
                 break;
 8585  
             case BIND:
 8586  
                 {
 8587  0
                 alt90=7;
 8588  
                 }
 8589  0
                 break;
 8590  
             default:
 8591  0
                 NoViableAltException nvae =
 8592  
                     new NoViableAltException("", 90, 0, input);
 8593  
 
 8594  0
                 throw nvae;
 8595  
 
 8596  
             }
 8597  
 
 8598  0
             switch (alt90) {
 8599  
                 case 1 :
 8600  
                     // com\\googlecode\\sparkleg\\SparqlT.g:259:7: groupOrUnionGraphPattern
 8601  
                     {
 8602  0
                     root_0 = (CommonTree)adaptor.nil();
 8603  
 
 8604  
 
 8605  0
                     _last = (CommonTree)input.LT(1);
 8606  0
                     pushFollow(FOLLOW_groupOrUnionGraphPattern_in_graphPatternNotTriples1699);
 8607  0
                     groupOrUnionGraphPattern215=groupOrUnionGraphPattern();
 8608  
 
 8609  0
                     state._fsp--;
 8610  
 
 8611  0
                     adaptor.addChild(root_0, groupOrUnionGraphPattern215.getTree());
 8612  
 
 8613  
 
 8614  
                     }
 8615  0
                     break;
 8616  
                 case 2 :
 8617  
                     // com\\googlecode\\sparkleg\\SparqlT.g:259:34: optionalGraphPattern
 8618  
                     {
 8619  0
                     root_0 = (CommonTree)adaptor.nil();
 8620  
 
 8621  
 
 8622  0
                     _last = (CommonTree)input.LT(1);
 8623  0
                     pushFollow(FOLLOW_optionalGraphPattern_in_graphPatternNotTriples1703);
 8624  0
                     optionalGraphPattern216=optionalGraphPattern();
 8625  
 
 8626  0
                     state._fsp--;
 8627  
 
 8628  0
                     adaptor.addChild(root_0, optionalGraphPattern216.getTree());
 8629  
 
 8630  
 
 8631  
                     }
 8632  0
                     break;
 8633  
                 case 3 :
 8634  
                     // com\\googlecode\\sparkleg\\SparqlT.g:259:57: minusGraphPattern
 8635  
                     {
 8636  0
                     root_0 = (CommonTree)adaptor.nil();
 8637  
 
 8638  
 
 8639  0
                     _last = (CommonTree)input.LT(1);
 8640  0
                     pushFollow(FOLLOW_minusGraphPattern_in_graphPatternNotTriples1707);
 8641  0
                     minusGraphPattern217=minusGraphPattern();
 8642  
 
 8643  0
                     state._fsp--;
 8644  
 
 8645  0
                     adaptor.addChild(root_0, minusGraphPattern217.getTree());
 8646  
 
 8647  
 
 8648  
                     }
 8649  0
                     break;
 8650  
                 case 4 :
 8651  
                     // com\\googlecode\\sparkleg\\SparqlT.g:259:77: graphGraphPattern
 8652  
                     {
 8653  0
                     root_0 = (CommonTree)adaptor.nil();
 8654  
 
 8655  
 
 8656  0
                     _last = (CommonTree)input.LT(1);
 8657  0
                     pushFollow(FOLLOW_graphGraphPattern_in_graphPatternNotTriples1711);
 8658  0
                     graphGraphPattern218=graphGraphPattern();
 8659  
 
 8660  0
                     state._fsp--;
 8661  
 
 8662  0
                     adaptor.addChild(root_0, graphGraphPattern218.getTree());
 8663  
 
 8664  
 
 8665  
                     }
 8666  0
                     break;
 8667  
                 case 5 :
 8668  
                     // com\\googlecode\\sparkleg\\SparqlT.g:259:97: serviceGraphPattern
 8669  
                     {
 8670  0
                     root_0 = (CommonTree)adaptor.nil();
 8671  
 
 8672  
 
 8673  0
                     _last = (CommonTree)input.LT(1);
 8674  0
                     pushFollow(FOLLOW_serviceGraphPattern_in_graphPatternNotTriples1715);
 8675  0
                     serviceGraphPattern219=serviceGraphPattern();
 8676  
 
 8677  0
                     state._fsp--;
 8678  
 
 8679  0
                     adaptor.addChild(root_0, serviceGraphPattern219.getTree());
 8680  
 
 8681  
 
 8682  
                     }
 8683  0
                     break;
 8684  
                 case 6 :
 8685  
                     // com\\googlecode\\sparkleg\\SparqlT.g:259:119: filter
 8686  
                     {
 8687  0
                     root_0 = (CommonTree)adaptor.nil();
 8688  
 
 8689  
 
 8690  0
                     _last = (CommonTree)input.LT(1);
 8691  0
                     pushFollow(FOLLOW_filter_in_graphPatternNotTriples1719);
 8692  0
                     filter220=filter();
 8693  
 
 8694  0
                     state._fsp--;
 8695  
 
 8696  0
                     adaptor.addChild(root_0, filter220.getTree());
 8697  
 
 8698  
 
 8699  
                     }
 8700  0
                     break;
 8701  
                 case 7 :
 8702  
                     // com\\googlecode\\sparkleg\\SparqlT.g:259:128: bind
 8703  
                     {
 8704  0
                     root_0 = (CommonTree)adaptor.nil();
 8705  
 
 8706  
 
 8707  0
                     _last = (CommonTree)input.LT(1);
 8708  0
                     pushFollow(FOLLOW_bind_in_graphPatternNotTriples1723);
 8709  0
                     bind221=bind();
 8710  
 
 8711  0
                     state._fsp--;
 8712  
 
 8713  0
                     adaptor.addChild(root_0, bind221.getTree());
 8714  
 
 8715  
 
 8716  
                     }
 8717  
                     break;
 8718  
 
 8719  
             }
 8720  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 8721  
 
 8722  
         }
 8723  0
         catch (RecognitionException re) {
 8724  0
             reportError(re);
 8725  0
             recover(input,re);
 8726  
         }
 8727  
 
 8728  0
         finally {
 8729  
                 // do for sure before leaving
 8730  0
         }
 8731  0
         return retval;
 8732  
     }
 8733  
     // $ANTLR end "graphPatternNotTriples"
 8734  
 
 8735  
 
 8736  0
     public static class optionalGraphPattern_return extends TreeRuleReturnScope {
 8737  
         CommonTree tree;
 8738  0
         public Object getTree() { return tree; }
 8739  
     };
 8740  
 
 8741  
 
 8742  
     // $ANTLR start "optionalGraphPattern"
 8743  
     // com\\googlecode\\sparkleg\\SparqlT.g:262:1: optionalGraphPattern : ^( OPTIONAL groupGraphPattern ) ;
 8744  
     public final SparqlT.optionalGraphPattern_return optionalGraphPattern() throws RecognitionException {
 8745  0
         SparqlT.optionalGraphPattern_return retval = new SparqlT.optionalGraphPattern_return();
 8746  0
         retval.start = input.LT(1);
 8747  
 
 8748  
 
 8749  0
         CommonTree root_0 = null;
 8750  
 
 8751  0
         CommonTree _first_0 = null;
 8752  0
         CommonTree _last = null;
 8753  
 
 8754  0
         CommonTree OPTIONAL222=null;
 8755  0
         SparqlT.groupGraphPattern_return groupGraphPattern223 =null;
 8756  
 
 8757  
 
 8758  0
         CommonTree OPTIONAL222_tree=null;
 8759  
 
 8760  
         try {
 8761  
             // com\\googlecode\\sparkleg\\SparqlT.g:263:5: ( ^( OPTIONAL groupGraphPattern ) )
 8762  
             // com\\googlecode\\sparkleg\\SparqlT.g:263:7: ^( OPTIONAL groupGraphPattern )
 8763  
             {
 8764  0
             root_0 = (CommonTree)adaptor.nil();
 8765  
 
 8766  
 
 8767  0
             _last = (CommonTree)input.LT(1);
 8768  
             {
 8769  0
             CommonTree _save_last_1 = _last;
 8770  0
             CommonTree _first_1 = null;
 8771  0
             CommonTree root_1 = (CommonTree)adaptor.nil();
 8772  0
             _last = (CommonTree)input.LT(1);
 8773  0
             OPTIONAL222=(CommonTree)match(input,OPTIONAL,FOLLOW_OPTIONAL_in_optionalGraphPattern1741); 
 8774  0
             OPTIONAL222_tree = (CommonTree)adaptor.dupNode(OPTIONAL222);
 8775  
 
 8776  
 
 8777  0
             root_1 = (CommonTree)adaptor.becomeRoot(OPTIONAL222_tree, root_1);
 8778  
 
 8779  
 
 8780  0
             match(input, Token.DOWN, null); 
 8781  0
             _last = (CommonTree)input.LT(1);
 8782  0
             pushFollow(FOLLOW_groupGraphPattern_in_optionalGraphPattern1743);
 8783  0
             groupGraphPattern223=groupGraphPattern();
 8784  
 
 8785  0
             state._fsp--;
 8786  
 
 8787  0
             adaptor.addChild(root_1, groupGraphPattern223.getTree());
 8788  
 
 8789  
 
 8790  0
             match(input, Token.UP, null); 
 8791  0
             adaptor.addChild(root_0, root_1);
 8792  0
             _last = _save_last_1;
 8793  
             }
 8794  
 
 8795  
 
 8796  
             }
 8797  
 
 8798  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 8799  
 
 8800  
         }
 8801  0
         catch (RecognitionException re) {
 8802  0
             reportError(re);
 8803  0
             recover(input,re);
 8804  
         }
 8805  
 
 8806  0
         finally {
 8807  
                 // do for sure before leaving
 8808  0
         }
 8809  0
         return retval;
 8810  
     }
 8811  
     // $ANTLR end "optionalGraphPattern"
 8812  
 
 8813  
 
 8814  0
     public static class graphGraphPattern_return extends TreeRuleReturnScope {
 8815  
         CommonTree tree;
 8816  0
         public Object getTree() { return tree; }
 8817  
     };
 8818  
 
 8819  
 
 8820  
     // $ANTLR start "graphGraphPattern"
 8821  
     // com\\googlecode\\sparkleg\\SparqlT.g:266:1: graphGraphPattern : ^( GRAPH varOrIRIref groupGraphPattern ) ;
 8822  
     public final SparqlT.graphGraphPattern_return graphGraphPattern() throws RecognitionException {
 8823  0
         SparqlT.graphGraphPattern_return retval = new SparqlT.graphGraphPattern_return();
 8824  0
         retval.start = input.LT(1);
 8825  
 
 8826  
 
 8827  0
         CommonTree root_0 = null;
 8828  
 
 8829  0
         CommonTree _first_0 = null;
 8830  0
         CommonTree _last = null;
 8831  
 
 8832  0
         CommonTree GRAPH224=null;
 8833  0
         SparqlT.varOrIRIref_return varOrIRIref225 =null;
 8834  
 
 8835  0
         SparqlT.groupGraphPattern_return groupGraphPattern226 =null;
 8836  
 
 8837  
 
 8838  0
         CommonTree GRAPH224_tree=null;
 8839  
 
 8840  
         try {
 8841  
             // com\\googlecode\\sparkleg\\SparqlT.g:267:5: ( ^( GRAPH varOrIRIref groupGraphPattern ) )
 8842  
             // com\\googlecode\\sparkleg\\SparqlT.g:267:7: ^( GRAPH varOrIRIref groupGraphPattern )
 8843  
             {
 8844  0
             root_0 = (CommonTree)adaptor.nil();
 8845  
 
 8846  
 
 8847  0
             _last = (CommonTree)input.LT(1);
 8848  
             {
 8849  0
             CommonTree _save_last_1 = _last;
 8850  0
             CommonTree _first_1 = null;
 8851  0
             CommonTree root_1 = (CommonTree)adaptor.nil();
 8852  0
             _last = (CommonTree)input.LT(1);
 8853  0
             GRAPH224=(CommonTree)match(input,GRAPH,FOLLOW_GRAPH_in_graphGraphPattern1762); 
 8854  0
             GRAPH224_tree = (CommonTree)adaptor.dupNode(GRAPH224);
 8855  
 
 8856  
 
 8857  0
             root_1 = (CommonTree)adaptor.becomeRoot(GRAPH224_tree, root_1);
 8858  
 
 8859  
 
 8860  0
             match(input, Token.DOWN, null); 
 8861  0
             _last = (CommonTree)input.LT(1);
 8862  0
             pushFollow(FOLLOW_varOrIRIref_in_graphGraphPattern1764);
 8863  0
             varOrIRIref225=varOrIRIref();
 8864  
 
 8865  0
             state._fsp--;
 8866  
 
 8867  0
             adaptor.addChild(root_1, varOrIRIref225.getTree());
 8868  
 
 8869  
 
 8870  0
             _last = (CommonTree)input.LT(1);
 8871  0
             pushFollow(FOLLOW_groupGraphPattern_in_graphGraphPattern1766);
 8872  0
             groupGraphPattern226=groupGraphPattern();
 8873  
 
 8874  0
             state._fsp--;
 8875  
 
 8876  0
             adaptor.addChild(root_1, groupGraphPattern226.getTree());
 8877  
 
 8878  
 
 8879  0
             match(input, Token.UP, null); 
 8880  0
             adaptor.addChild(root_0, root_1);
 8881  0
             _last = _save_last_1;
 8882  
             }
 8883  
 
 8884  
 
 8885  
             }
 8886  
 
 8887  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 8888  
 
 8889  
         }
 8890  0
         catch (RecognitionException re) {
 8891  0
             reportError(re);
 8892  0
             recover(input,re);
 8893  
         }
 8894  
 
 8895  0
         finally {
 8896  
                 // do for sure before leaving
 8897  0
         }
 8898  0
         return retval;
 8899  
     }
 8900  
     // $ANTLR end "graphGraphPattern"
 8901  
 
 8902  
 
 8903  0
     public static class serviceGraphPattern_return extends TreeRuleReturnScope {
 8904  
         CommonTree tree;
 8905  0
         public Object getTree() { return tree; }
 8906  
     };
 8907  
 
 8908  
 
 8909  
     // $ANTLR start "serviceGraphPattern"
 8910  
     // com\\googlecode\\sparkleg\\SparqlT.g:270:1: serviceGraphPattern : ^( SERVICE ( SILENT )? varOrIRIref groupGraphPattern ) ;
 8911  
     public final SparqlT.serviceGraphPattern_return serviceGraphPattern() throws RecognitionException {
 8912  0
         SparqlT.serviceGraphPattern_return retval = new SparqlT.serviceGraphPattern_return();
 8913  0
         retval.start = input.LT(1);
 8914  
 
 8915  
 
 8916  0
         CommonTree root_0 = null;
 8917  
 
 8918  0
         CommonTree _first_0 = null;
 8919  0
         CommonTree _last = null;
 8920  
 
 8921  0
         CommonTree SERVICE227=null;
 8922  0
         CommonTree SILENT228=null;
 8923  0
         SparqlT.varOrIRIref_return varOrIRIref229 =null;
 8924  
 
 8925  0
         SparqlT.groupGraphPattern_return groupGraphPattern230 =null;
 8926  
 
 8927  
 
 8928  0
         CommonTree SERVICE227_tree=null;
 8929  0
         CommonTree SILENT228_tree=null;
 8930  
 
 8931  
         try {
 8932  
             // com\\googlecode\\sparkleg\\SparqlT.g:271:5: ( ^( SERVICE ( SILENT )? varOrIRIref groupGraphPattern ) )
 8933  
             // com\\googlecode\\sparkleg\\SparqlT.g:271:7: ^( SERVICE ( SILENT )? varOrIRIref groupGraphPattern )
 8934  
             {
 8935  0
             root_0 = (CommonTree)adaptor.nil();
 8936  
 
 8937  
 
 8938  0
             _last = (CommonTree)input.LT(1);
 8939  
             {
 8940  0
             CommonTree _save_last_1 = _last;
 8941  0
             CommonTree _first_1 = null;
 8942  0
             CommonTree root_1 = (CommonTree)adaptor.nil();
 8943  0
             _last = (CommonTree)input.LT(1);
 8944  0
             SERVICE227=(CommonTree)match(input,SERVICE,FOLLOW_SERVICE_in_serviceGraphPattern1785); 
 8945  0
             SERVICE227_tree = (CommonTree)adaptor.dupNode(SERVICE227);
 8946  
 
 8947  
 
 8948  0
             root_1 = (CommonTree)adaptor.becomeRoot(SERVICE227_tree, root_1);
 8949  
 
 8950  
 
 8951  0
             match(input, Token.DOWN, null); 
 8952  
             // com\\googlecode\\sparkleg\\SparqlT.g:271:17: ( SILENT )?
 8953  0
             int alt91=2;
 8954  0
             switch ( input.LA(1) ) {
 8955  
                 case SILENT:
 8956  
                     {
 8957  0
                     alt91=1;
 8958  
                     }
 8959  
                     break;
 8960  
             }
 8961  
 
 8962  0
             switch (alt91) {
 8963  
                 case 1 :
 8964  
                     // com\\googlecode\\sparkleg\\SparqlT.g:271:17: SILENT
 8965  
                     {
 8966  0
                     _last = (CommonTree)input.LT(1);
 8967  0
                     SILENT228=(CommonTree)match(input,SILENT,FOLLOW_SILENT_in_serviceGraphPattern1787); 
 8968  0
                     SILENT228_tree = (CommonTree)adaptor.dupNode(SILENT228);
 8969  
 
 8970  
 
 8971  0
                     adaptor.addChild(root_1, SILENT228_tree);
 8972  
 
 8973  
 
 8974  
                     }
 8975  
                     break;
 8976  
 
 8977  
             }
 8978  
 
 8979  
 
 8980  0
             _last = (CommonTree)input.LT(1);
 8981  0
             pushFollow(FOLLOW_varOrIRIref_in_serviceGraphPattern1790);
 8982  0
             varOrIRIref229=varOrIRIref();
 8983  
 
 8984  0
             state._fsp--;
 8985  
 
 8986  0
             adaptor.addChild(root_1, varOrIRIref229.getTree());
 8987  
 
 8988  
 
 8989  0
             _last = (CommonTree)input.LT(1);
 8990  0
             pushFollow(FOLLOW_groupGraphPattern_in_serviceGraphPattern1792);
 8991  0
             groupGraphPattern230=groupGraphPattern();
 8992  
 
 8993  0
             state._fsp--;
 8994  
 
 8995  0
             adaptor.addChild(root_1, groupGraphPattern230.getTree());
 8996  
 
 8997  
 
 8998  0
             match(input, Token.UP, null); 
 8999  0
             adaptor.addChild(root_0, root_1);
 9000  0
             _last = _save_last_1;
 9001  
             }
 9002  
 
 9003  
 
 9004  
             }
 9005  
 
 9006  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 9007  
 
 9008  
         }
 9009  0
         catch (RecognitionException re) {
 9010  0
             reportError(re);
 9011  0
             recover(input,re);
 9012  
         }
 9013  
 
 9014  0
         finally {
 9015  
                 // do for sure before leaving
 9016  0
         }
 9017  0
         return retval;
 9018  
     }
 9019  
     // $ANTLR end "serviceGraphPattern"
 9020  
 
 9021  
 
 9022  0
     public static class bind_return extends TreeRuleReturnScope {
 9023  
         CommonTree tree;
 9024  0
         public Object getTree() { return tree; }
 9025  
     };
 9026  
 
 9027  
 
 9028  
     // $ANTLR start "bind"
 9029  
     // com\\googlecode\\sparkleg\\SparqlT.g:274:1: bind : ^( BIND expression ^( AS var ) ) ;
 9030  
     public final SparqlT.bind_return bind() throws RecognitionException {
 9031  0
         SparqlT.bind_return retval = new SparqlT.bind_return();
 9032  0
         retval.start = input.LT(1);
 9033  
 
 9034  
 
 9035  0
         CommonTree root_0 = null;
 9036  
 
 9037  0
         CommonTree _first_0 = null;
 9038  0
         CommonTree _last = null;
 9039  
 
 9040  0
         CommonTree BIND231=null;
 9041  0
         CommonTree AS233=null;
 9042  0
         SparqlT.expression_return expression232 =null;
 9043  
 
 9044  0
         SparqlT.var_return var234 =null;
 9045  
 
 9046  
 
 9047  0
         CommonTree BIND231_tree=null;
 9048  0
         CommonTree AS233_tree=null;
 9049  
 
 9050  
         try {
 9051  
             // com\\googlecode\\sparkleg\\SparqlT.g:275:5: ( ^( BIND expression ^( AS var ) ) )
 9052  
             // com\\googlecode\\sparkleg\\SparqlT.g:275:7: ^( BIND expression ^( AS var ) )
 9053  
             {
 9054  0
             root_0 = (CommonTree)adaptor.nil();
 9055  
 
 9056  
 
 9057  0
             _last = (CommonTree)input.LT(1);
 9058  
             {
 9059  0
             CommonTree _save_last_1 = _last;
 9060  0
             CommonTree _first_1 = null;
 9061  0
             CommonTree root_1 = (CommonTree)adaptor.nil();
 9062  0
             _last = (CommonTree)input.LT(1);
 9063  0
             BIND231=(CommonTree)match(input,BIND,FOLLOW_BIND_in_bind1815); 
 9064  0
             BIND231_tree = (CommonTree)adaptor.dupNode(BIND231);
 9065  
 
 9066  
 
 9067  0
             root_1 = (CommonTree)adaptor.becomeRoot(BIND231_tree, root_1);
 9068  
 
 9069  
 
 9070  0
             match(input, Token.DOWN, null); 
 9071  0
             _last = (CommonTree)input.LT(1);
 9072  0
             pushFollow(FOLLOW_expression_in_bind1817);
 9073  0
             expression232=expression();
 9074  
 
 9075  0
             state._fsp--;
 9076  
 
 9077  0
             adaptor.addChild(root_1, expression232.getTree());
 9078  
 
 9079  
 
 9080  0
             _last = (CommonTree)input.LT(1);
 9081  
             {
 9082  0
             CommonTree _save_last_2 = _last;
 9083  0
             CommonTree _first_2 = null;
 9084  0
             CommonTree root_2 = (CommonTree)adaptor.nil();
 9085  0
             _last = (CommonTree)input.LT(1);
 9086  0
             AS233=(CommonTree)match(input,AS,FOLLOW_AS_in_bind1820); 
 9087  0
             AS233_tree = (CommonTree)adaptor.dupNode(AS233);
 9088  
 
 9089  
 
 9090  0
             root_2 = (CommonTree)adaptor.becomeRoot(AS233_tree, root_2);
 9091  
 
 9092  
 
 9093  0
             match(input, Token.DOWN, null); 
 9094  0
             _last = (CommonTree)input.LT(1);
 9095  0
             pushFollow(FOLLOW_var_in_bind1822);
 9096  0
             var234=var();
 9097  
 
 9098  0
             state._fsp--;
 9099  
 
 9100  0
             adaptor.addChild(root_2, var234.getTree());
 9101  
 
 9102  
 
 9103  0
             match(input, Token.UP, null); 
 9104  0
             adaptor.addChild(root_1, root_2);
 9105  0
             _last = _save_last_2;
 9106  
             }
 9107  
 
 9108  
 
 9109  0
             match(input, Token.UP, null); 
 9110  0
             adaptor.addChild(root_0, root_1);
 9111  0
             _last = _save_last_1;
 9112  
             }
 9113  
 
 9114  
 
 9115  
             }
 9116  
 
 9117  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 9118  
 
 9119  
         }
 9120  0
         catch (RecognitionException re) {
 9121  0
             reportError(re);
 9122  0
             recover(input,re);
 9123  
         }
 9124  
 
 9125  0
         finally {
 9126  
                 // do for sure before leaving
 9127  0
         }
 9128  0
         return retval;
 9129  
     }
 9130  
     // $ANTLR end "bind"
 9131  
 
 9132  
 
 9133  0
     public static class minusGraphPattern_return extends TreeRuleReturnScope {
 9134  
         CommonTree tree;
 9135  0
         public Object getTree() { return tree; }
 9136  
     };
 9137  
 
 9138  
 
 9139  
     // $ANTLR start "minusGraphPattern"
 9140  
     // com\\googlecode\\sparkleg\\SparqlT.g:278:1: minusGraphPattern : ^( MINUS_KEYWORD groupGraphPattern ) ;
 9141  
     public final SparqlT.minusGraphPattern_return minusGraphPattern() throws RecognitionException {
 9142  0
         SparqlT.minusGraphPattern_return retval = new SparqlT.minusGraphPattern_return();
 9143  0
         retval.start = input.LT(1);
 9144  
 
 9145  
 
 9146  0
         CommonTree root_0 = null;
 9147  
 
 9148  0
         CommonTree _first_0 = null;
 9149  0
         CommonTree _last = null;
 9150  
 
 9151  0
         CommonTree MINUS_KEYWORD235=null;
 9152  0
         SparqlT.groupGraphPattern_return groupGraphPattern236 =null;
 9153  
 
 9154  
 
 9155  0
         CommonTree MINUS_KEYWORD235_tree=null;
 9156  
 
 9157  
         try {
 9158  
             // com\\googlecode\\sparkleg\\SparqlT.g:279:5: ( ^( MINUS_KEYWORD groupGraphPattern ) )
 9159  
             // com\\googlecode\\sparkleg\\SparqlT.g:279:7: ^( MINUS_KEYWORD groupGraphPattern )
 9160  
             {
 9161  0
             root_0 = (CommonTree)adaptor.nil();
 9162  
 
 9163  
 
 9164  0
             _last = (CommonTree)input.LT(1);
 9165  
             {
 9166  0
             CommonTree _save_last_1 = _last;
 9167  0
             CommonTree _first_1 = null;
 9168  0
             CommonTree root_1 = (CommonTree)adaptor.nil();
 9169  0
             _last = (CommonTree)input.LT(1);
 9170  0
             MINUS_KEYWORD235=(CommonTree)match(input,MINUS_KEYWORD,FOLLOW_MINUS_KEYWORD_in_minusGraphPattern1848); 
 9171  0
             MINUS_KEYWORD235_tree = (CommonTree)adaptor.dupNode(MINUS_KEYWORD235);
 9172  
 
 9173  
 
 9174  0
             root_1 = (CommonTree)adaptor.becomeRoot(MINUS_KEYWORD235_tree, root_1);
 9175  
 
 9176  
 
 9177  0
             match(input, Token.DOWN, null); 
 9178  0
             _last = (CommonTree)input.LT(1);
 9179  0
             pushFollow(FOLLOW_groupGraphPattern_in_minusGraphPattern1850);
 9180  0
             groupGraphPattern236=groupGraphPattern();
 9181  
 
 9182  0
             state._fsp--;
 9183  
 
 9184  0
             adaptor.addChild(root_1, groupGraphPattern236.getTree());
 9185  
 
 9186  
 
 9187  0
             match(input, Token.UP, null); 
 9188  0
             adaptor.addChild(root_0, root_1);
 9189  0
             _last = _save_last_1;
 9190  
             }
 9191  
 
 9192  
 
 9193  
             }
 9194  
 
 9195  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 9196  
 
 9197  
         }
 9198  0
         catch (RecognitionException re) {
 9199  0
             reportError(re);
 9200  0
             recover(input,re);
 9201  
         }
 9202  
 
 9203  0
         finally {
 9204  
                 // do for sure before leaving
 9205  0
         }
 9206  0
         return retval;
 9207  
     }
 9208  
     // $ANTLR end "minusGraphPattern"
 9209  
 
 9210  
 
 9211  0
     public static class groupOrUnionGraphPattern_return extends TreeRuleReturnScope {
 9212  
         CommonTree tree;
 9213  0
         public Object getTree() { return tree; }
 9214  
     };
 9215  
 
 9216  
 
 9217  
     // $ANTLR start "groupOrUnionGraphPattern"
 9218  
     // com\\googlecode\\sparkleg\\SparqlT.g:282:1: groupOrUnionGraphPattern : ( ^( UNION groupGraphPattern groupGraphPattern ) | groupGraphPattern );
 9219  
     public final SparqlT.groupOrUnionGraphPattern_return groupOrUnionGraphPattern() throws RecognitionException {
 9220  0
         SparqlT.groupOrUnionGraphPattern_return retval = new SparqlT.groupOrUnionGraphPattern_return();
 9221  0
         retval.start = input.LT(1);
 9222  
 
 9223  
 
 9224  0
         CommonTree root_0 = null;
 9225  
 
 9226  0
         CommonTree _first_0 = null;
 9227  0
         CommonTree _last = null;
 9228  
 
 9229  0
         CommonTree UNION237=null;
 9230  0
         SparqlT.groupGraphPattern_return groupGraphPattern238 =null;
 9231  
 
 9232  0
         SparqlT.groupGraphPattern_return groupGraphPattern239 =null;
 9233  
 
 9234  0
         SparqlT.groupGraphPattern_return groupGraphPattern240 =null;
 9235  
 
 9236  
 
 9237  0
         CommonTree UNION237_tree=null;
 9238  
 
 9239  
         try {
 9240  
             // com\\googlecode\\sparkleg\\SparqlT.g:283:5: ( ^( UNION groupGraphPattern groupGraphPattern ) | groupGraphPattern )
 9241  0
             int alt92=2;
 9242  0
             switch ( input.LA(1) ) {
 9243  
             case UNION:
 9244  
                 {
 9245  0
                 alt92=1;
 9246  
                 }
 9247  0
                 break;
 9248  
             case GROUP_GRAPH_PATTERN:
 9249  
                 {
 9250  0
                 alt92=2;
 9251  
                 }
 9252  0
                 break;
 9253  
             default:
 9254  0
                 NoViableAltException nvae =
 9255  
                     new NoViableAltException("", 92, 0, input);
 9256  
 
 9257  0
                 throw nvae;
 9258  
 
 9259  
             }
 9260  
 
 9261  0
             switch (alt92) {
 9262  
                 case 1 :
 9263  
                     // com\\googlecode\\sparkleg\\SparqlT.g:283:7: ^( UNION groupGraphPattern groupGraphPattern )
 9264  
                     {
 9265  0
                     root_0 = (CommonTree)adaptor.nil();
 9266  
 
 9267  
 
 9268  0
                     _last = (CommonTree)input.LT(1);
 9269  
                     {
 9270  0
                     CommonTree _save_last_1 = _last;
 9271  0
                     CommonTree _first_1 = null;
 9272  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 9273  0
                     _last = (CommonTree)input.LT(1);
 9274  0
                     UNION237=(CommonTree)match(input,UNION,FOLLOW_UNION_in_groupOrUnionGraphPattern1869); 
 9275  0
                     UNION237_tree = (CommonTree)adaptor.dupNode(UNION237);
 9276  
 
 9277  
 
 9278  0
                     root_1 = (CommonTree)adaptor.becomeRoot(UNION237_tree, root_1);
 9279  
 
 9280  
 
 9281  0
                     match(input, Token.DOWN, null); 
 9282  0
                     _last = (CommonTree)input.LT(1);
 9283  0
                     pushFollow(FOLLOW_groupGraphPattern_in_groupOrUnionGraphPattern1871);
 9284  0
                     groupGraphPattern238=groupGraphPattern();
 9285  
 
 9286  0
                     state._fsp--;
 9287  
 
 9288  0
                     adaptor.addChild(root_1, groupGraphPattern238.getTree());
 9289  
 
 9290  
 
 9291  0
                     _last = (CommonTree)input.LT(1);
 9292  0
                     pushFollow(FOLLOW_groupGraphPattern_in_groupOrUnionGraphPattern1873);
 9293  0
                     groupGraphPattern239=groupGraphPattern();
 9294  
 
 9295  0
                     state._fsp--;
 9296  
 
 9297  0
                     adaptor.addChild(root_1, groupGraphPattern239.getTree());
 9298  
 
 9299  
 
 9300  0
                     match(input, Token.UP, null); 
 9301  0
                     adaptor.addChild(root_0, root_1);
 9302  0
                     _last = _save_last_1;
 9303  
                     }
 9304  
 
 9305  
 
 9306  
                     }
 9307  0
                     break;
 9308  
                 case 2 :
 9309  
                     // com\\googlecode\\sparkleg\\SparqlT.g:284:7: groupGraphPattern
 9310  
                     {
 9311  0
                     root_0 = (CommonTree)adaptor.nil();
 9312  
 
 9313  
 
 9314  0
                     _last = (CommonTree)input.LT(1);
 9315  0
                     pushFollow(FOLLOW_groupGraphPattern_in_groupOrUnionGraphPattern1882);
 9316  0
                     groupGraphPattern240=groupGraphPattern();
 9317  
 
 9318  0
                     state._fsp--;
 9319  
 
 9320  0
                     adaptor.addChild(root_0, groupGraphPattern240.getTree());
 9321  
 
 9322  
 
 9323  
                     }
 9324  
                     break;
 9325  
 
 9326  
             }
 9327  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 9328  
 
 9329  
         }
 9330  0
         catch (RecognitionException re) {
 9331  0
             reportError(re);
 9332  0
             recover(input,re);
 9333  
         }
 9334  
 
 9335  0
         finally {
 9336  
                 // do for sure before leaving
 9337  0
         }
 9338  0
         return retval;
 9339  
     }
 9340  
     // $ANTLR end "groupOrUnionGraphPattern"
 9341  
 
 9342  
 
 9343  0
     public static class filter_return extends TreeRuleReturnScope {
 9344  
         CommonTree tree;
 9345  0
         public Object getTree() { return tree; }
 9346  
     };
 9347  
 
 9348  
 
 9349  
     // $ANTLR start "filter"
 9350  
     // com\\googlecode\\sparkleg\\SparqlT.g:287:1: filter : ^( FILTER constraint ) ;
 9351  
     public final SparqlT.filter_return filter() throws RecognitionException {
 9352  0
         SparqlT.filter_return retval = new SparqlT.filter_return();
 9353  0
         retval.start = input.LT(1);
 9354  
 
 9355  
 
 9356  0
         CommonTree root_0 = null;
 9357  
 
 9358  0
         CommonTree _first_0 = null;
 9359  0
         CommonTree _last = null;
 9360  
 
 9361  0
         CommonTree FILTER241=null;
 9362  0
         SparqlT.constraint_return constraint242 =null;
 9363  
 
 9364  
 
 9365  0
         CommonTree FILTER241_tree=null;
 9366  
 
 9367  
         try {
 9368  
             // com\\googlecode\\sparkleg\\SparqlT.g:288:5: ( ^( FILTER constraint ) )
 9369  
             // com\\googlecode\\sparkleg\\SparqlT.g:288:7: ^( FILTER constraint )
 9370  
             {
 9371  0
             root_0 = (CommonTree)adaptor.nil();
 9372  
 
 9373  
 
 9374  0
             _last = (CommonTree)input.LT(1);
 9375  
             {
 9376  0
             CommonTree _save_last_1 = _last;
 9377  0
             CommonTree _first_1 = null;
 9378  0
             CommonTree root_1 = (CommonTree)adaptor.nil();
 9379  0
             _last = (CommonTree)input.LT(1);
 9380  0
             FILTER241=(CommonTree)match(input,FILTER,FOLLOW_FILTER_in_filter1900); 
 9381  0
             FILTER241_tree = (CommonTree)adaptor.dupNode(FILTER241);
 9382  
 
 9383  
 
 9384  0
             root_1 = (CommonTree)adaptor.becomeRoot(FILTER241_tree, root_1);
 9385  
 
 9386  
 
 9387  0
             match(input, Token.DOWN, null); 
 9388  0
             _last = (CommonTree)input.LT(1);
 9389  0
             pushFollow(FOLLOW_constraint_in_filter1902);
 9390  0
             constraint242=constraint();
 9391  
 
 9392  0
             state._fsp--;
 9393  
 
 9394  0
             adaptor.addChild(root_1, constraint242.getTree());
 9395  
 
 9396  
 
 9397  0
             match(input, Token.UP, null); 
 9398  0
             adaptor.addChild(root_0, root_1);
 9399  0
             _last = _save_last_1;
 9400  
             }
 9401  
 
 9402  
 
 9403  
             }
 9404  
 
 9405  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 9406  
 
 9407  
         }
 9408  0
         catch (RecognitionException re) {
 9409  0
             reportError(re);
 9410  0
             recover(input,re);
 9411  
         }
 9412  
 
 9413  0
         finally {
 9414  
                 // do for sure before leaving
 9415  0
         }
 9416  0
         return retval;
 9417  
     }
 9418  
     // $ANTLR end "filter"
 9419  
 
 9420  
 
 9421  0
     public static class constraint_return extends TreeRuleReturnScope {
 9422  
         CommonTree tree;
 9423  0
         public Object getTree() { return tree; }
 9424  
     };
 9425  
 
 9426  
 
 9427  
     // $ANTLR start "constraint"
 9428  
     // com\\googlecode\\sparkleg\\SparqlT.g:291:1: constraint : ( expression | builtInCall | functionCall );
 9429  
     public final SparqlT.constraint_return constraint() throws RecognitionException {
 9430  0
         SparqlT.constraint_return retval = new SparqlT.constraint_return();
 9431  0
         retval.start = input.LT(1);
 9432  
 
 9433  
 
 9434  0
         CommonTree root_0 = null;
 9435  
 
 9436  0
         CommonTree _first_0 = null;
 9437  0
         CommonTree _last = null;
 9438  
 
 9439  0
         SparqlT.expression_return expression243 =null;
 9440  
 
 9441  0
         SparqlT.builtInCall_return builtInCall244 =null;
 9442  
 
 9443  0
         SparqlT.functionCall_return functionCall245 =null;
 9444  
 
 9445  
 
 9446  
 
 9447  
         try {
 9448  
             // com\\googlecode\\sparkleg\\SparqlT.g:292:5: ( expression | builtInCall | functionCall )
 9449  0
             int alt93=3;
 9450  0
             switch ( input.LA(1) ) {
 9451  
             case AND:
 9452  
             case ASTERISK:
 9453  
             case DECIMAL_NEGATIVE:
 9454  
             case DECIMAL_POSITIVE:
 9455  
             case DIVIDE:
 9456  
             case DOUBLE_NEGATIVE:
 9457  
             case DOUBLE_POSITIVE:
 9458  
             case EQUAL:
 9459  
             case GREATER:
 9460  
             case GREATER_EQUAL:
 9461  
             case IN:
 9462  
             case INTEGER_NEGATIVE:
 9463  
             case INTEGER_POSITIVE:
 9464  
             case LESS:
 9465  
             case LESS_EQUAL:
 9466  
             case MINUS:
 9467  
             case NOT:
 9468  
             case NOT_EQUAL:
 9469  
             case OR:
 9470  
             case PLUS:
 9471  
             case UNARY:
 9472  
                 {
 9473  0
                 alt93=1;
 9474  
                 }
 9475  0
                 break;
 9476  
             case ABS:
 9477  
             case BNODE:
 9478  
             case BOUND:
 9479  
             case CEIL:
 9480  
             case COALESCE:
 9481  
             case CONCAT:
 9482  
             case CONTAINS:
 9483  
             case DATATYPE:
 9484  
             case DAY:
 9485  
             case ENCODE_FOR_URI:
 9486  
             case EXISTS:
 9487  
             case FLOOR:
 9488  
             case HOURS:
 9489  
             case IF:
 9490  
             case IRI:
 9491  
             case ISBLANK:
 9492  
             case ISIRI:
 9493  
             case ISLITERAL:
 9494  
             case ISNUMERIC:
 9495  
             case ISURI:
 9496  
             case LANG:
 9497  
             case LANGMATCHES:
 9498  
             case LCASE:
 9499  
             case MD5:
 9500  
             case MINUTES:
 9501  
             case MONTH:
 9502  
             case NOT_EXISTS:
 9503  
             case NOW:
 9504  
             case RAND:
 9505  
             case REGEX:
 9506  
             case REPLACE:
 9507  
             case ROUND:
 9508  
             case SAMETERM:
 9509  
             case SECONDS:
 9510  
             case SHA1:
 9511  
             case SHA224:
 9512  
             case SHA256:
 9513  
             case SHA384:
 9514  
             case SHA512:
 9515  
             case STR:
 9516  
             case STRAFTER:
 9517  
             case STRBEFORE:
 9518  
             case STRDT:
 9519  
             case STRENDS:
 9520  
             case STRLANG:
 9521  
             case STRLEN:
 9522  
             case STRSTARTS:
 9523  
             case SUBSTR:
 9524  
             case TIMEZONE:
 9525  
             case TZ:
 9526  
             case UCASE:
 9527  
             case URI:
 9528  
             case YEAR:
 9529  
                 {
 9530  0
                 alt93=2;
 9531  
                 }
 9532  0
                 break;
 9533  
             case FUNCTION:
 9534  
                 {
 9535  0
                 alt93=3;
 9536  
                 }
 9537  0
                 break;
 9538  
             default:
 9539  0
                 NoViableAltException nvae =
 9540  
                     new NoViableAltException("", 93, 0, input);
 9541  
 
 9542  0
                 throw nvae;
 9543  
 
 9544  
             }
 9545  
 
 9546  0
             switch (alt93) {
 9547  
                 case 1 :
 9548  
                     // com\\googlecode\\sparkleg\\SparqlT.g:292:7: expression
 9549  
                     {
 9550  0
                     root_0 = (CommonTree)adaptor.nil();
 9551  
 
 9552  
 
 9553  0
                     _last = (CommonTree)input.LT(1);
 9554  0
                     pushFollow(FOLLOW_expression_in_constraint1920);
 9555  0
                     expression243=expression();
 9556  
 
 9557  0
                     state._fsp--;
 9558  
 
 9559  0
                     adaptor.addChild(root_0, expression243.getTree());
 9560  
 
 9561  
 
 9562  
                     }
 9563  0
                     break;
 9564  
                 case 2 :
 9565  
                     // com\\googlecode\\sparkleg\\SparqlT.g:293:7: builtInCall
 9566  
                     {
 9567  0
                     root_0 = (CommonTree)adaptor.nil();
 9568  
 
 9569  
 
 9570  0
                     _last = (CommonTree)input.LT(1);
 9571  0
                     pushFollow(FOLLOW_builtInCall_in_constraint1928);
 9572  0
                     builtInCall244=builtInCall();
 9573  
 
 9574  0
                     state._fsp--;
 9575  
 
 9576  0
                     adaptor.addChild(root_0, builtInCall244.getTree());
 9577  
 
 9578  
 
 9579  
                     }
 9580  0
                     break;
 9581  
                 case 3 :
 9582  
                     // com\\googlecode\\sparkleg\\SparqlT.g:294:7: functionCall
 9583  
                     {
 9584  0
                     root_0 = (CommonTree)adaptor.nil();
 9585  
 
 9586  
 
 9587  0
                     _last = (CommonTree)input.LT(1);
 9588  0
                     pushFollow(FOLLOW_functionCall_in_constraint1936);
 9589  0
                     functionCall245=functionCall();
 9590  
 
 9591  0
                     state._fsp--;
 9592  
 
 9593  0
                     adaptor.addChild(root_0, functionCall245.getTree());
 9594  
 
 9595  
 
 9596  
                     }
 9597  
                     break;
 9598  
 
 9599  
             }
 9600  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 9601  
 
 9602  
         }
 9603  0
         catch (RecognitionException re) {
 9604  0
             reportError(re);
 9605  0
             recover(input,re);
 9606  
         }
 9607  
 
 9608  0
         finally {
 9609  
                 // do for sure before leaving
 9610  0
         }
 9611  0
         return retval;
 9612  
     }
 9613  
     // $ANTLR end "constraint"
 9614  
 
 9615  
 
 9616  0
     public static class functionCall_return extends TreeRuleReturnScope {
 9617  
         CommonTree tree;
 9618  0
         public Object getTree() { return tree; }
 9619  
     };
 9620  
 
 9621  
 
 9622  
     // $ANTLR start "functionCall"
 9623  
     // com\\googlecode\\sparkleg\\SparqlT.g:297:1: functionCall : ^( FUNCTION iriRef ^( ARG_LIST argList ) ) ;
 9624  
     public final SparqlT.functionCall_return functionCall() throws RecognitionException {
 9625  0
         SparqlT.functionCall_return retval = new SparqlT.functionCall_return();
 9626  0
         retval.start = input.LT(1);
 9627  
 
 9628  
 
 9629  0
         CommonTree root_0 = null;
 9630  
 
 9631  0
         CommonTree _first_0 = null;
 9632  0
         CommonTree _last = null;
 9633  
 
 9634  0
         CommonTree FUNCTION246=null;
 9635  0
         CommonTree ARG_LIST248=null;
 9636  0
         SparqlT.iriRef_return iriRef247 =null;
 9637  
 
 9638  0
         SparqlT.argList_return argList249 =null;
 9639  
 
 9640  
 
 9641  0
         CommonTree FUNCTION246_tree=null;
 9642  0
         CommonTree ARG_LIST248_tree=null;
 9643  
 
 9644  
         try {
 9645  
             // com\\googlecode\\sparkleg\\SparqlT.g:298:5: ( ^( FUNCTION iriRef ^( ARG_LIST argList ) ) )
 9646  
             // com\\googlecode\\sparkleg\\SparqlT.g:298:7: ^( FUNCTION iriRef ^( ARG_LIST argList ) )
 9647  
             {
 9648  0
             root_0 = (CommonTree)adaptor.nil();
 9649  
 
 9650  
 
 9651  0
             _last = (CommonTree)input.LT(1);
 9652  
             {
 9653  0
             CommonTree _save_last_1 = _last;
 9654  0
             CommonTree _first_1 = null;
 9655  0
             CommonTree root_1 = (CommonTree)adaptor.nil();
 9656  0
             _last = (CommonTree)input.LT(1);
 9657  0
             FUNCTION246=(CommonTree)match(input,FUNCTION,FOLLOW_FUNCTION_in_functionCall1954); 
 9658  0
             FUNCTION246_tree = (CommonTree)adaptor.dupNode(FUNCTION246);
 9659  
 
 9660  
 
 9661  0
             root_1 = (CommonTree)adaptor.becomeRoot(FUNCTION246_tree, root_1);
 9662  
 
 9663  
 
 9664  0
             match(input, Token.DOWN, null); 
 9665  0
             _last = (CommonTree)input.LT(1);
 9666  0
             pushFollow(FOLLOW_iriRef_in_functionCall1956);
 9667  0
             iriRef247=iriRef();
 9668  
 
 9669  0
             state._fsp--;
 9670  
 
 9671  0
             adaptor.addChild(root_1, iriRef247.getTree());
 9672  
 
 9673  
 
 9674  0
             _last = (CommonTree)input.LT(1);
 9675  
             {
 9676  0
             CommonTree _save_last_2 = _last;
 9677  0
             CommonTree _first_2 = null;
 9678  0
             CommonTree root_2 = (CommonTree)adaptor.nil();
 9679  0
             _last = (CommonTree)input.LT(1);
 9680  0
             ARG_LIST248=(CommonTree)match(input,ARG_LIST,FOLLOW_ARG_LIST_in_functionCall1959); 
 9681  0
             ARG_LIST248_tree = (CommonTree)adaptor.dupNode(ARG_LIST248);
 9682  
 
 9683  
 
 9684  0
             root_2 = (CommonTree)adaptor.becomeRoot(ARG_LIST248_tree, root_2);
 9685  
 
 9686  
 
 9687  0
             if ( input.LA(1)==Token.DOWN ) {
 9688  0
                 match(input, Token.DOWN, null); 
 9689  0
                 _last = (CommonTree)input.LT(1);
 9690  0
                 pushFollow(FOLLOW_argList_in_functionCall1961);
 9691  0
                 argList249=argList();
 9692  
 
 9693  0
                 state._fsp--;
 9694  
 
 9695  0
                 adaptor.addChild(root_2, argList249.getTree());
 9696  
 
 9697  
 
 9698  0
                 match(input, Token.UP, null); 
 9699  
             }
 9700  0
             adaptor.addChild(root_1, root_2);
 9701  0
             _last = _save_last_2;
 9702  
             }
 9703  
 
 9704  
 
 9705  0
             match(input, Token.UP, null); 
 9706  0
             adaptor.addChild(root_0, root_1);
 9707  0
             _last = _save_last_1;
 9708  
             }
 9709  
 
 9710  
 
 9711  
             }
 9712  
 
 9713  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 9714  
 
 9715  
         }
 9716  0
         catch (RecognitionException re) {
 9717  0
             reportError(re);
 9718  0
             recover(input,re);
 9719  
         }
 9720  
 
 9721  0
         finally {
 9722  
                 // do for sure before leaving
 9723  0
         }
 9724  0
         return retval;
 9725  
     }
 9726  
     // $ANTLR end "functionCall"
 9727  
 
 9728  
 
 9729  0
     public static class argList_return extends TreeRuleReturnScope {
 9730  
         CommonTree tree;
 9731  0
         public Object getTree() { return tree; }
 9732  
     };
 9733  
 
 9734  
 
 9735  
     // $ANTLR start "argList"
 9736  
     // com\\googlecode\\sparkleg\\SparqlT.g:301:1: argList : ( nil | ( DISTINCT )? ( expression )* );
 9737  
     public final SparqlT.argList_return argList() throws RecognitionException {
 9738  0
         SparqlT.argList_return retval = new SparqlT.argList_return();
 9739  0
         retval.start = input.LT(1);
 9740  
 
 9741  
 
 9742  0
         CommonTree root_0 = null;
 9743  
 
 9744  0
         CommonTree _first_0 = null;
 9745  0
         CommonTree _last = null;
 9746  
 
 9747  0
         CommonTree DISTINCT251=null;
 9748  0
         SparqlT.nil_return nil250 =null;
 9749  
 
 9750  0
         SparqlT.expression_return expression252 =null;
 9751  
 
 9752  
 
 9753  0
         CommonTree DISTINCT251_tree=null;
 9754  
 
 9755  
         try {
 9756  
             // com\\googlecode\\sparkleg\\SparqlT.g:302:5: ( nil | ( DISTINCT )? ( expression )* )
 9757  0
             int alt96=2;
 9758  0
             switch ( input.LA(1) ) {
 9759  
             case OPEN_BRACE:
 9760  
                 {
 9761  0
                 alt96=1;
 9762  
                 }
 9763  0
                 break;
 9764  
             case UP:
 9765  
             case AND:
 9766  
             case ASTERISK:
 9767  
             case DECIMAL_NEGATIVE:
 9768  
             case DECIMAL_POSITIVE:
 9769  
             case DISTINCT:
 9770  
             case DIVIDE:
 9771  
             case DOUBLE_NEGATIVE:
 9772  
             case DOUBLE_POSITIVE:
 9773  
             case EQUAL:
 9774  
             case GREATER:
 9775  
             case GREATER_EQUAL:
 9776  
             case IN:
 9777  
             case INTEGER_NEGATIVE:
 9778  
             case INTEGER_POSITIVE:
 9779  
             case LESS:
 9780  
             case LESS_EQUAL:
 9781  
             case MINUS:
 9782  
             case NOT:
 9783  
             case NOT_EQUAL:
 9784  
             case OR:
 9785  
             case PLUS:
 9786  
             case UNARY:
 9787  
                 {
 9788  0
                 alt96=2;
 9789  
                 }
 9790  0
                 break;
 9791  
             default:
 9792  0
                 NoViableAltException nvae =
 9793  
                     new NoViableAltException("", 96, 0, input);
 9794  
 
 9795  0
                 throw nvae;
 9796  
 
 9797  
             }
 9798  
 
 9799  0
             switch (alt96) {
 9800  
                 case 1 :
 9801  
                     // com\\googlecode\\sparkleg\\SparqlT.g:302:7: nil
 9802  
                     {
 9803  0
                     root_0 = (CommonTree)adaptor.nil();
 9804  
 
 9805  
 
 9806  0
                     _last = (CommonTree)input.LT(1);
 9807  0
                     pushFollow(FOLLOW_nil_in_argList1980);
 9808  0
                     nil250=nil();
 9809  
 
 9810  0
                     state._fsp--;
 9811  
 
 9812  0
                     adaptor.addChild(root_0, nil250.getTree());
 9813  
 
 9814  
 
 9815  
                     }
 9816  0
                     break;
 9817  
                 case 2 :
 9818  
                     // com\\googlecode\\sparkleg\\SparqlT.g:303:7: ( DISTINCT )? ( expression )*
 9819  
                     {
 9820  0
                     root_0 = (CommonTree)adaptor.nil();
 9821  
 
 9822  
 
 9823  
                     // com\\googlecode\\sparkleg\\SparqlT.g:303:7: ( DISTINCT )?
 9824  0
                     int alt94=2;
 9825  0
                     switch ( input.LA(1) ) {
 9826  
                         case DISTINCT:
 9827  
                             {
 9828  0
                             alt94=1;
 9829  
                             }
 9830  
                             break;
 9831  
                     }
 9832  
 
 9833  0
                     switch (alt94) {
 9834  
                         case 1 :
 9835  
                             // com\\googlecode\\sparkleg\\SparqlT.g:303:7: DISTINCT
 9836  
                             {
 9837  0
                             _last = (CommonTree)input.LT(1);
 9838  0
                             DISTINCT251=(CommonTree)match(input,DISTINCT,FOLLOW_DISTINCT_in_argList1988); 
 9839  0
                             DISTINCT251_tree = (CommonTree)adaptor.dupNode(DISTINCT251);
 9840  
 
 9841  
 
 9842  0
                             adaptor.addChild(root_0, DISTINCT251_tree);
 9843  
 
 9844  
 
 9845  
                             }
 9846  
                             break;
 9847  
 
 9848  
                     }
 9849  
 
 9850  
 
 9851  
                     // com\\googlecode\\sparkleg\\SparqlT.g:303:17: ( expression )*
 9852  
                     loop95:
 9853  
                     do {
 9854  0
                         int alt95=2;
 9855  0
                         switch ( input.LA(1) ) {
 9856  
                         case AND:
 9857  
                         case ASTERISK:
 9858  
                         case DECIMAL_NEGATIVE:
 9859  
                         case DECIMAL_POSITIVE:
 9860  
                         case DIVIDE:
 9861  
                         case DOUBLE_NEGATIVE:
 9862  
                         case DOUBLE_POSITIVE:
 9863  
                         case EQUAL:
 9864  
                         case GREATER:
 9865  
                         case GREATER_EQUAL:
 9866  
                         case IN:
 9867  
                         case INTEGER_NEGATIVE:
 9868  
                         case INTEGER_POSITIVE:
 9869  
                         case LESS:
 9870  
                         case LESS_EQUAL:
 9871  
                         case MINUS:
 9872  
                         case NOT:
 9873  
                         case NOT_EQUAL:
 9874  
                         case OR:
 9875  
                         case PLUS:
 9876  
                         case UNARY:
 9877  
                             {
 9878  0
                             alt95=1;
 9879  
                             }
 9880  
                             break;
 9881  
 
 9882  
                         }
 9883  
 
 9884  0
                         switch (alt95) {
 9885  
                             case 1 :
 9886  
                                 // com\\googlecode\\sparkleg\\SparqlT.g:303:17: expression
 9887  
                                 {
 9888  0
                                 _last = (CommonTree)input.LT(1);
 9889  0
                                 pushFollow(FOLLOW_expression_in_argList1991);
 9890  0
                                 expression252=expression();
 9891  
 
 9892  0
                                 state._fsp--;
 9893  
 
 9894  0
                                 adaptor.addChild(root_0, expression252.getTree());
 9895  
 
 9896  
 
 9897  
                                 }
 9898  0
                                 break;
 9899  
 
 9900  
                             default :
 9901  0
                                 break loop95;
 9902  
                         }
 9903  0
                     } while (true);
 9904  
 
 9905  
 
 9906  
                     }
 9907  
                     break;
 9908  
 
 9909  
             }
 9910  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 9911  
 
 9912  
         }
 9913  0
         catch (RecognitionException re) {
 9914  0
             reportError(re);
 9915  0
             recover(input,re);
 9916  
         }
 9917  
 
 9918  0
         finally {
 9919  
                 // do for sure before leaving
 9920  0
         }
 9921  0
         return retval;
 9922  
     }
 9923  
     // $ANTLR end "argList"
 9924  
 
 9925  
 
 9926  0
     public static class expressionList_return extends TreeRuleReturnScope {
 9927  
         CommonTree tree;
 9928  0
         public Object getTree() { return tree; }
 9929  
     };
 9930  
 
 9931  
 
 9932  
     // $ANTLR start "expressionList"
 9933  
     // com\\googlecode\\sparkleg\\SparqlT.g:306:1: expressionList : ( ^( EXPRESSION_LIST ( expression )+ ) | ^( EXPRESSION_LIST nil ) );
 9934  
     public final SparqlT.expressionList_return expressionList() throws RecognitionException {
 9935  0
         SparqlT.expressionList_return retval = new SparqlT.expressionList_return();
 9936  0
         retval.start = input.LT(1);
 9937  
 
 9938  
 
 9939  0
         CommonTree root_0 = null;
 9940  
 
 9941  0
         CommonTree _first_0 = null;
 9942  0
         CommonTree _last = null;
 9943  
 
 9944  0
         CommonTree EXPRESSION_LIST253=null;
 9945  0
         CommonTree EXPRESSION_LIST255=null;
 9946  0
         SparqlT.expression_return expression254 =null;
 9947  
 
 9948  0
         SparqlT.nil_return nil256 =null;
 9949  
 
 9950  
 
 9951  0
         CommonTree EXPRESSION_LIST253_tree=null;
 9952  0
         CommonTree EXPRESSION_LIST255_tree=null;
 9953  
 
 9954  
         try {
 9955  
             // com\\googlecode\\sparkleg\\SparqlT.g:307:5: ( ^( EXPRESSION_LIST ( expression )+ ) | ^( EXPRESSION_LIST nil ) )
 9956  0
             int alt98=2;
 9957  0
             switch ( input.LA(1) ) {
 9958  
             case EXPRESSION_LIST:
 9959  
                 {
 9960  0
                 switch ( input.LA(2) ) {
 9961  
                 case DOWN:
 9962  
                     {
 9963  0
                     switch ( input.LA(3) ) {
 9964  
                     case AND:
 9965  
                     case ASTERISK:
 9966  
                     case DECIMAL_NEGATIVE:
 9967  
                     case DECIMAL_POSITIVE:
 9968  
                     case DIVIDE:
 9969  
                     case DOUBLE_NEGATIVE:
 9970  
                     case DOUBLE_POSITIVE:
 9971  
                     case EQUAL:
 9972  
                     case GREATER:
 9973  
                     case GREATER_EQUAL:
 9974  
                     case IN:
 9975  
                     case INTEGER_NEGATIVE:
 9976  
                     case INTEGER_POSITIVE:
 9977  
                     case LESS:
 9978  
                     case LESS_EQUAL:
 9979  
                     case MINUS:
 9980  
                     case NOT:
 9981  
                     case NOT_EQUAL:
 9982  
                     case OR:
 9983  
                     case PLUS:
 9984  
                     case UNARY:
 9985  
                         {
 9986  0
                         alt98=1;
 9987  
                         }
 9988  0
                         break;
 9989  
                     case OPEN_BRACE:
 9990  
                         {
 9991  0
                         alt98=2;
 9992  
                         }
 9993  0
                         break;
 9994  
                     default:
 9995  0
                         NoViableAltException nvae =
 9996  
                             new NoViableAltException("", 98, 2, input);
 9997  
 
 9998  0
                         throw nvae;
 9999  
 
 10000  
                     }
 10001  
 
 10002  
                     }
 10003  0
                     break;
 10004  
                 default:
 10005  0
                     NoViableAltException nvae =
 10006  
                         new NoViableAltException("", 98, 1, input);
 10007  
 
 10008  0
                     throw nvae;
 10009  
 
 10010  
                 }
 10011  
 
 10012  
                 }
 10013  0
                 break;
 10014  
             default:
 10015  0
                 NoViableAltException nvae =
 10016  
                     new NoViableAltException("", 98, 0, input);
 10017  
 
 10018  0
                 throw nvae;
 10019  
 
 10020  
             }
 10021  
 
 10022  0
             switch (alt98) {
 10023  
                 case 1 :
 10024  
                     // com\\googlecode\\sparkleg\\SparqlT.g:307:7: ^( EXPRESSION_LIST ( expression )+ )
 10025  
                     {
 10026  0
                     root_0 = (CommonTree)adaptor.nil();
 10027  
 
 10028  
 
 10029  0
                     _last = (CommonTree)input.LT(1);
 10030  
                     {
 10031  0
                     CommonTree _save_last_1 = _last;
 10032  0
                     CommonTree _first_1 = null;
 10033  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 10034  0
                     _last = (CommonTree)input.LT(1);
 10035  0
                     EXPRESSION_LIST253=(CommonTree)match(input,EXPRESSION_LIST,FOLLOW_EXPRESSION_LIST_in_expressionList2010); 
 10036  0
                     EXPRESSION_LIST253_tree = (CommonTree)adaptor.dupNode(EXPRESSION_LIST253);
 10037  
 
 10038  
 
 10039  0
                     root_1 = (CommonTree)adaptor.becomeRoot(EXPRESSION_LIST253_tree, root_1);
 10040  
 
 10041  
 
 10042  0
                     match(input, Token.DOWN, null); 
 10043  
                     // com\\googlecode\\sparkleg\\SparqlT.g:307:25: ( expression )+
 10044  0
                     int cnt97=0;
 10045  
                     loop97:
 10046  
                     do {
 10047  0
                         int alt97=2;
 10048  0
                         switch ( input.LA(1) ) {
 10049  
                         case AND:
 10050  
                         case ASTERISK:
 10051  
                         case DECIMAL_NEGATIVE:
 10052  
                         case DECIMAL_POSITIVE:
 10053  
                         case DIVIDE:
 10054  
                         case DOUBLE_NEGATIVE:
 10055  
                         case DOUBLE_POSITIVE:
 10056  
                         case EQUAL:
 10057  
                         case GREATER:
 10058  
                         case GREATER_EQUAL:
 10059  
                         case IN:
 10060  
                         case INTEGER_NEGATIVE:
 10061  
                         case INTEGER_POSITIVE:
 10062  
                         case LESS:
 10063  
                         case LESS_EQUAL:
 10064  
                         case MINUS:
 10065  
                         case NOT:
 10066  
                         case NOT_EQUAL:
 10067  
                         case OR:
 10068  
                         case PLUS:
 10069  
                         case UNARY:
 10070  
                             {
 10071  0
                             alt97=1;
 10072  
                             }
 10073  
                             break;
 10074  
 
 10075  
                         }
 10076  
 
 10077  0
                         switch (alt97) {
 10078  
                             case 1 :
 10079  
                                 // com\\googlecode\\sparkleg\\SparqlT.g:307:25: expression
 10080  
                                 {
 10081  0
                                 _last = (CommonTree)input.LT(1);
 10082  0
                                 pushFollow(FOLLOW_expression_in_expressionList2012);
 10083  0
                                 expression254=expression();
 10084  
 
 10085  0
                                 state._fsp--;
 10086  
 
 10087  0
                                 adaptor.addChild(root_1, expression254.getTree());
 10088  
 
 10089  
 
 10090  
                                 }
 10091  0
                                 break;
 10092  
 
 10093  
                             default :
 10094  0
                                 if ( cnt97 >= 1 ) break loop97;
 10095  0
                                 EarlyExitException eee =
 10096  
                                     new EarlyExitException(97, input);
 10097  0
                                 throw eee;
 10098  
                         }
 10099  0
                         cnt97++;
 10100  0
                     } while (true);
 10101  
 
 10102  
 
 10103  0
                     match(input, Token.UP, null); 
 10104  0
                     adaptor.addChild(root_0, root_1);
 10105  0
                     _last = _save_last_1;
 10106  
                     }
 10107  
 
 10108  
 
 10109  
                     }
 10110  0
                     break;
 10111  
                 case 2 :
 10112  
                     // com\\googlecode\\sparkleg\\SparqlT.g:308:7: ^( EXPRESSION_LIST nil )
 10113  
                     {
 10114  0
                     root_0 = (CommonTree)adaptor.nil();
 10115  
 
 10116  
 
 10117  0
                     _last = (CommonTree)input.LT(1);
 10118  
                     {
 10119  0
                     CommonTree _save_last_1 = _last;
 10120  0
                     CommonTree _first_1 = null;
 10121  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 10122  0
                     _last = (CommonTree)input.LT(1);
 10123  0
                     EXPRESSION_LIST255=(CommonTree)match(input,EXPRESSION_LIST,FOLLOW_EXPRESSION_LIST_in_expressionList2023); 
 10124  0
                     EXPRESSION_LIST255_tree = (CommonTree)adaptor.dupNode(EXPRESSION_LIST255);
 10125  
 
 10126  
 
 10127  0
                     root_1 = (CommonTree)adaptor.becomeRoot(EXPRESSION_LIST255_tree, root_1);
 10128  
 
 10129  
 
 10130  0
                     match(input, Token.DOWN, null); 
 10131  0
                     _last = (CommonTree)input.LT(1);
 10132  0
                     pushFollow(FOLLOW_nil_in_expressionList2025);
 10133  0
                     nil256=nil();
 10134  
 
 10135  0
                     state._fsp--;
 10136  
 
 10137  0
                     adaptor.addChild(root_1, nil256.getTree());
 10138  
 
 10139  
 
 10140  0
                     match(input, Token.UP, null); 
 10141  0
                     adaptor.addChild(root_0, root_1);
 10142  0
                     _last = _save_last_1;
 10143  
                     }
 10144  
 
 10145  
 
 10146  
                     }
 10147  
                     break;
 10148  
 
 10149  
             }
 10150  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 10151  
 
 10152  
         }
 10153  0
         catch (RecognitionException re) {
 10154  0
             reportError(re);
 10155  0
             recover(input,re);
 10156  
         }
 10157  
 
 10158  0
         finally {
 10159  
                 // do for sure before leaving
 10160  0
         }
 10161  0
         return retval;
 10162  
     }
 10163  
     // $ANTLR end "expressionList"
 10164  
 
 10165  
 
 10166  0
     public static class constructTemplate_return extends TreeRuleReturnScope {
 10167  
         CommonTree tree;
 10168  0
         public Object getTree() { return tree; }
 10169  
     };
 10170  
 
 10171  
 
 10172  
     // $ANTLR start "constructTemplate"
 10173  
     // com\\googlecode\\sparkleg\\SparqlT.g:311:1: constructTemplate : ^( CONSTRUCT_TRIPLES ( constructTriples )? ) ;
 10174  
     public final SparqlT.constructTemplate_return constructTemplate() throws RecognitionException {
 10175  0
         SparqlT.constructTemplate_return retval = new SparqlT.constructTemplate_return();
 10176  0
         retval.start = input.LT(1);
 10177  
 
 10178  
 
 10179  0
         CommonTree root_0 = null;
 10180  
 
 10181  0
         CommonTree _first_0 = null;
 10182  0
         CommonTree _last = null;
 10183  
 
 10184  0
         CommonTree CONSTRUCT_TRIPLES257=null;
 10185  0
         SparqlT.constructTriples_return constructTriples258 =null;
 10186  
 
 10187  
 
 10188  0
         CommonTree CONSTRUCT_TRIPLES257_tree=null;
 10189  
 
 10190  
         try {
 10191  
             // com\\googlecode\\sparkleg\\SparqlT.g:312:5: ( ^( CONSTRUCT_TRIPLES ( constructTriples )? ) )
 10192  
             // com\\googlecode\\sparkleg\\SparqlT.g:312:7: ^( CONSTRUCT_TRIPLES ( constructTriples )? )
 10193  
             {
 10194  0
             root_0 = (CommonTree)adaptor.nil();
 10195  
 
 10196  
 
 10197  0
             _last = (CommonTree)input.LT(1);
 10198  
             {
 10199  0
             CommonTree _save_last_1 = _last;
 10200  0
             CommonTree _first_1 = null;
 10201  0
             CommonTree root_1 = (CommonTree)adaptor.nil();
 10202  0
             _last = (CommonTree)input.LT(1);
 10203  0
             CONSTRUCT_TRIPLES257=(CommonTree)match(input,CONSTRUCT_TRIPLES,FOLLOW_CONSTRUCT_TRIPLES_in_constructTemplate2045); 
 10204  0
             CONSTRUCT_TRIPLES257_tree = (CommonTree)adaptor.dupNode(CONSTRUCT_TRIPLES257);
 10205  
 
 10206  
 
 10207  0
             root_1 = (CommonTree)adaptor.becomeRoot(CONSTRUCT_TRIPLES257_tree, root_1);
 10208  
 
 10209  
 
 10210  0
             if ( input.LA(1)==Token.DOWN ) {
 10211  0
                 match(input, Token.DOWN, null); 
 10212  
                 // com\\googlecode\\sparkleg\\SparqlT.g:312:27: ( constructTriples )?
 10213  0
                 int alt99=2;
 10214  0
                 switch ( input.LA(1) ) {
 10215  
                     case TRIPLES_SAME_SUBJECT:
 10216  
                         {
 10217  0
                         alt99=1;
 10218  
                         }
 10219  
                         break;
 10220  
                 }
 10221  
 
 10222  0
                 switch (alt99) {
 10223  
                     case 1 :
 10224  
                         // com\\googlecode\\sparkleg\\SparqlT.g:312:27: constructTriples
 10225  
                         {
 10226  0
                         _last = (CommonTree)input.LT(1);
 10227  0
                         pushFollow(FOLLOW_constructTriples_in_constructTemplate2047);
 10228  0
                         constructTriples258=constructTriples();
 10229  
 
 10230  0
                         state._fsp--;
 10231  
 
 10232  0
                         adaptor.addChild(root_1, constructTriples258.getTree());
 10233  
 
 10234  
 
 10235  
                         }
 10236  
                         break;
 10237  
 
 10238  
                 }
 10239  
 
 10240  
 
 10241  0
                 match(input, Token.UP, null); 
 10242  
             }
 10243  0
             adaptor.addChild(root_0, root_1);
 10244  0
             _last = _save_last_1;
 10245  
             }
 10246  
 
 10247  
 
 10248  
             }
 10249  
 
 10250  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 10251  
 
 10252  
         }
 10253  0
         catch (RecognitionException re) {
 10254  0
             reportError(re);
 10255  0
             recover(input,re);
 10256  
         }
 10257  
 
 10258  0
         finally {
 10259  
                 // do for sure before leaving
 10260  0
         }
 10261  0
         return retval;
 10262  
     }
 10263  
     // $ANTLR end "constructTemplate"
 10264  
 
 10265  
 
 10266  0
     public static class constructTriples_return extends TreeRuleReturnScope {
 10267  
         CommonTree tree;
 10268  0
         public Object getTree() { return tree; }
 10269  
     };
 10270  
 
 10271  
 
 10272  
     // $ANTLR start "constructTriples"
 10273  
     // com\\googlecode\\sparkleg\\SparqlT.g:315:1: constructTriples : ( triplesSameSubject )+ ;
 10274  
     public final SparqlT.constructTriples_return constructTriples() throws RecognitionException {
 10275  0
         SparqlT.constructTriples_return retval = new SparqlT.constructTriples_return();
 10276  0
         retval.start = input.LT(1);
 10277  
 
 10278  
 
 10279  0
         CommonTree root_0 = null;
 10280  
 
 10281  0
         CommonTree _first_0 = null;
 10282  0
         CommonTree _last = null;
 10283  
 
 10284  0
         SparqlT.triplesSameSubject_return triplesSameSubject259 =null;
 10285  
 
 10286  
 
 10287  
 
 10288  
         try {
 10289  
             // com\\googlecode\\sparkleg\\SparqlT.g:316:5: ( ( triplesSameSubject )+ )
 10290  
             // com\\googlecode\\sparkleg\\SparqlT.g:316:7: ( triplesSameSubject )+
 10291  
             {
 10292  0
             root_0 = (CommonTree)adaptor.nil();
 10293  
 
 10294  
 
 10295  
             // com\\googlecode\\sparkleg\\SparqlT.g:316:7: ( triplesSameSubject )+
 10296  0
             int cnt100=0;
 10297  
             loop100:
 10298  
             do {
 10299  0
                 int alt100=2;
 10300  0
                 switch ( input.LA(1) ) {
 10301  
                 case TRIPLES_SAME_SUBJECT:
 10302  
                     {
 10303  0
                     alt100=1;
 10304  
                     }
 10305  
                     break;
 10306  
 
 10307  
                 }
 10308  
 
 10309  0
                 switch (alt100) {
 10310  
                     case 1 :
 10311  
                         // com\\googlecode\\sparkleg\\SparqlT.g:316:7: triplesSameSubject
 10312  
                         {
 10313  0
                         _last = (CommonTree)input.LT(1);
 10314  0
                         pushFollow(FOLLOW_triplesSameSubject_in_constructTriples2066);
 10315  0
                         triplesSameSubject259=triplesSameSubject();
 10316  
 
 10317  0
                         state._fsp--;
 10318  
 
 10319  0
                         adaptor.addChild(root_0, triplesSameSubject259.getTree());
 10320  
 
 10321  
 
 10322  
                         }
 10323  0
                         break;
 10324  
 
 10325  
                     default :
 10326  0
                         if ( cnt100 >= 1 ) break loop100;
 10327  0
                         EarlyExitException eee =
 10328  
                             new EarlyExitException(100, input);
 10329  0
                         throw eee;
 10330  
                 }
 10331  0
                 cnt100++;
 10332  0
             } while (true);
 10333  
 
 10334  
 
 10335  
             }
 10336  
 
 10337  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 10338  
 
 10339  
         }
 10340  0
         catch (RecognitionException re) {
 10341  0
             reportError(re);
 10342  0
             recover(input,re);
 10343  
         }
 10344  
 
 10345  0
         finally {
 10346  
                 // do for sure before leaving
 10347  0
         }
 10348  0
         return retval;
 10349  
     }
 10350  
     // $ANTLR end "constructTriples"
 10351  
 
 10352  
 
 10353  0
     public static class triplesSameSubject_return extends TreeRuleReturnScope {
 10354  
         CommonTree tree;
 10355  0
         public Object getTree() { return tree; }
 10356  
     };
 10357  
 
 10358  
 
 10359  
     // $ANTLR start "triplesSameSubject"
 10360  
     // com\\googlecode\\sparkleg\\SparqlT.g:319:1: triplesSameSubject : ( ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) propertyListNotEmpty ) | ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? ) );
 10361  
     public final SparqlT.triplesSameSubject_return triplesSameSubject() throws RecognitionException {
 10362  0
         SparqlT.triplesSameSubject_return retval = new SparqlT.triplesSameSubject_return();
 10363  0
         retval.start = input.LT(1);
 10364  
 
 10365  
 
 10366  0
         CommonTree root_0 = null;
 10367  
 
 10368  0
         CommonTree _first_0 = null;
 10369  0
         CommonTree _last = null;
 10370  
 
 10371  0
         CommonTree TRIPLES_SAME_SUBJECT260=null;
 10372  0
         CommonTree SUBJECT261=null;
 10373  0
         CommonTree TRIPLES_SAME_SUBJECT264=null;
 10374  0
         SparqlT.varOrTerm_return varOrTerm262 =null;
 10375  
 
 10376  0
         SparqlT.propertyListNotEmpty_return propertyListNotEmpty263 =null;
 10377  
 
 10378  0
         SparqlT.triplesNode_return triplesNode265 =null;
 10379  
 
 10380  0
         SparqlT.propertyListNotEmpty_return propertyListNotEmpty266 =null;
 10381  
 
 10382  
 
 10383  0
         CommonTree TRIPLES_SAME_SUBJECT260_tree=null;
 10384  0
         CommonTree SUBJECT261_tree=null;
 10385  0
         CommonTree TRIPLES_SAME_SUBJECT264_tree=null;
 10386  
 
 10387  
         try {
 10388  
             // com\\googlecode\\sparkleg\\SparqlT.g:320:5: ( ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) propertyListNotEmpty ) | ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? ) )
 10389  0
             int alt102=2;
 10390  0
             switch ( input.LA(1) ) {
 10391  
             case TRIPLES_SAME_SUBJECT:
 10392  
                 {
 10393  0
                 switch ( input.LA(2) ) {
 10394  
                 case DOWN:
 10395  
                     {
 10396  0
                     switch ( input.LA(3) ) {
 10397  
                     case SUBJECT:
 10398  
                         {
 10399  0
                         alt102=1;
 10400  
                         }
 10401  0
                         break;
 10402  
                     case COLLECTION:
 10403  
                     case TRIPLES_NODE:
 10404  
                         {
 10405  0
                         alt102=2;
 10406  
                         }
 10407  0
                         break;
 10408  
                     default:
 10409  0
                         NoViableAltException nvae =
 10410  
                             new NoViableAltException("", 102, 2, input);
 10411  
 
 10412  0
                         throw nvae;
 10413  
 
 10414  
                     }
 10415  
 
 10416  
                     }
 10417  0
                     break;
 10418  
                 default:
 10419  0
                     NoViableAltException nvae =
 10420  
                         new NoViableAltException("", 102, 1, input);
 10421  
 
 10422  0
                     throw nvae;
 10423  
 
 10424  
                 }
 10425  
 
 10426  
                 }
 10427  0
                 break;
 10428  
             default:
 10429  0
                 NoViableAltException nvae =
 10430  
                     new NoViableAltException("", 102, 0, input);
 10431  
 
 10432  0
                 throw nvae;
 10433  
 
 10434  
             }
 10435  
 
 10436  0
             switch (alt102) {
 10437  
                 case 1 :
 10438  
                     // com\\googlecode\\sparkleg\\SparqlT.g:320:7: ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) propertyListNotEmpty )
 10439  
                     {
 10440  0
                     root_0 = (CommonTree)adaptor.nil();
 10441  
 
 10442  
 
 10443  0
                     _last = (CommonTree)input.LT(1);
 10444  
                     {
 10445  0
                     CommonTree _save_last_1 = _last;
 10446  0
                     CommonTree _first_1 = null;
 10447  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 10448  0
                     _last = (CommonTree)input.LT(1);
 10449  0
                     TRIPLES_SAME_SUBJECT260=(CommonTree)match(input,TRIPLES_SAME_SUBJECT,FOLLOW_TRIPLES_SAME_SUBJECT_in_triplesSameSubject2085); 
 10450  0
                     TRIPLES_SAME_SUBJECT260_tree = (CommonTree)adaptor.dupNode(TRIPLES_SAME_SUBJECT260);
 10451  
 
 10452  
 
 10453  0
                     root_1 = (CommonTree)adaptor.becomeRoot(TRIPLES_SAME_SUBJECT260_tree, root_1);
 10454  
 
 10455  
 
 10456  0
                     match(input, Token.DOWN, null); 
 10457  0
                     _last = (CommonTree)input.LT(1);
 10458  
                     {
 10459  0
                     CommonTree _save_last_2 = _last;
 10460  0
                     CommonTree _first_2 = null;
 10461  0
                     CommonTree root_2 = (CommonTree)adaptor.nil();
 10462  0
                     _last = (CommonTree)input.LT(1);
 10463  0
                     SUBJECT261=(CommonTree)match(input,SUBJECT,FOLLOW_SUBJECT_in_triplesSameSubject2088); 
 10464  0
                     SUBJECT261_tree = (CommonTree)adaptor.dupNode(SUBJECT261);
 10465  
 
 10466  
 
 10467  0
                     root_2 = (CommonTree)adaptor.becomeRoot(SUBJECT261_tree, root_2);
 10468  
 
 10469  
 
 10470  0
                     match(input, Token.DOWN, null); 
 10471  0
                     _last = (CommonTree)input.LT(1);
 10472  0
                     pushFollow(FOLLOW_varOrTerm_in_triplesSameSubject2090);
 10473  0
                     varOrTerm262=varOrTerm();
 10474  
 
 10475  0
                     state._fsp--;
 10476  
 
 10477  0
                     adaptor.addChild(root_2, varOrTerm262.getTree());
 10478  
 
 10479  
 
 10480  0
                     match(input, Token.UP, null); 
 10481  0
                     adaptor.addChild(root_1, root_2);
 10482  0
                     _last = _save_last_2;
 10483  
                     }
 10484  
 
 10485  
 
 10486  0
                     _last = (CommonTree)input.LT(1);
 10487  0
                     pushFollow(FOLLOW_propertyListNotEmpty_in_triplesSameSubject2093);
 10488  0
                     propertyListNotEmpty263=propertyListNotEmpty();
 10489  
 
 10490  0
                     state._fsp--;
 10491  
 
 10492  0
                     adaptor.addChild(root_1, propertyListNotEmpty263.getTree());
 10493  
 
 10494  
 
 10495  0
                     match(input, Token.UP, null); 
 10496  0
                     adaptor.addChild(root_0, root_1);
 10497  0
                     _last = _save_last_1;
 10498  
                     }
 10499  
 
 10500  
 
 10501  
                     }
 10502  0
                     break;
 10503  
                 case 2 :
 10504  
                     // com\\googlecode\\sparkleg\\SparqlT.g:321:7: ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? )
 10505  
                     {
 10506  0
                     root_0 = (CommonTree)adaptor.nil();
 10507  
 
 10508  
 
 10509  0
                     _last = (CommonTree)input.LT(1);
 10510  
                     {
 10511  0
                     CommonTree _save_last_1 = _last;
 10512  0
                     CommonTree _first_1 = null;
 10513  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 10514  0
                     _last = (CommonTree)input.LT(1);
 10515  0
                     TRIPLES_SAME_SUBJECT264=(CommonTree)match(input,TRIPLES_SAME_SUBJECT,FOLLOW_TRIPLES_SAME_SUBJECT_in_triplesSameSubject2103); 
 10516  0
                     TRIPLES_SAME_SUBJECT264_tree = (CommonTree)adaptor.dupNode(TRIPLES_SAME_SUBJECT264);
 10517  
 
 10518  
 
 10519  0
                     root_1 = (CommonTree)adaptor.becomeRoot(TRIPLES_SAME_SUBJECT264_tree, root_1);
 10520  
 
 10521  
 
 10522  0
                     match(input, Token.DOWN, null); 
 10523  0
                     _last = (CommonTree)input.LT(1);
 10524  0
                     pushFollow(FOLLOW_triplesNode_in_triplesSameSubject2105);
 10525  0
                     triplesNode265=triplesNode();
 10526  
 
 10527  0
                     state._fsp--;
 10528  
 
 10529  0
                     adaptor.addChild(root_1, triplesNode265.getTree());
 10530  
 
 10531  
 
 10532  
                     // com\\googlecode\\sparkleg\\SparqlT.g:321:42: ( propertyListNotEmpty )?
 10533  0
                     int alt101=2;
 10534  0
                     switch ( input.LA(1) ) {
 10535  
                         case PREDICATE:
 10536  
                             {
 10537  0
                             alt101=1;
 10538  
                             }
 10539  
                             break;
 10540  
                     }
 10541  
 
 10542  0
                     switch (alt101) {
 10543  
                         case 1 :
 10544  
                             // com\\googlecode\\sparkleg\\SparqlT.g:321:42: propertyListNotEmpty
 10545  
                             {
 10546  0
                             _last = (CommonTree)input.LT(1);
 10547  0
                             pushFollow(FOLLOW_propertyListNotEmpty_in_triplesSameSubject2107);
 10548  0
                             propertyListNotEmpty266=propertyListNotEmpty();
 10549  
 
 10550  0
                             state._fsp--;
 10551  
 
 10552  0
                             adaptor.addChild(root_1, propertyListNotEmpty266.getTree());
 10553  
 
 10554  
 
 10555  
                             }
 10556  
                             break;
 10557  
 
 10558  
                     }
 10559  
 
 10560  
 
 10561  0
                     match(input, Token.UP, null); 
 10562  0
                     adaptor.addChild(root_0, root_1);
 10563  0
                     _last = _save_last_1;
 10564  
                     }
 10565  
 
 10566  
 
 10567  
                     }
 10568  
                     break;
 10569  
 
 10570  
             }
 10571  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 10572  
 
 10573  
         }
 10574  0
         catch (RecognitionException re) {
 10575  0
             reportError(re);
 10576  0
             recover(input,re);
 10577  
         }
 10578  
 
 10579  0
         finally {
 10580  
                 // do for sure before leaving
 10581  0
         }
 10582  0
         return retval;
 10583  
     }
 10584  
     // $ANTLR end "triplesSameSubject"
 10585  
 
 10586  
 
 10587  0
     public static class propertyListNotEmpty_return extends TreeRuleReturnScope {
 10588  
         CommonTree tree;
 10589  0
         public Object getTree() { return tree; }
 10590  
     };
 10591  
 
 10592  
 
 10593  
     // $ANTLR start "propertyListNotEmpty"
 10594  
     // com\\googlecode\\sparkleg\\SparqlT.g:325:1: propertyListNotEmpty : ( propertyListNotEmptyDetails )+ ;
 10595  
     public final SparqlT.propertyListNotEmpty_return propertyListNotEmpty() throws RecognitionException {
 10596  0
         SparqlT.propertyListNotEmpty_return retval = new SparqlT.propertyListNotEmpty_return();
 10597  0
         retval.start = input.LT(1);
 10598  
 
 10599  
 
 10600  0
         CommonTree root_0 = null;
 10601  
 
 10602  0
         CommonTree _first_0 = null;
 10603  0
         CommonTree _last = null;
 10604  
 
 10605  0
         SparqlT.propertyListNotEmptyDetails_return propertyListNotEmptyDetails267 =null;
 10606  
 
 10607  
 
 10608  
 
 10609  
         try {
 10610  
             // com\\googlecode\\sparkleg\\SparqlT.g:326:5: ( ( propertyListNotEmptyDetails )+ )
 10611  
             // com\\googlecode\\sparkleg\\SparqlT.g:326:7: ( propertyListNotEmptyDetails )+
 10612  
             {
 10613  0
             root_0 = (CommonTree)adaptor.nil();
 10614  
 
 10615  
 
 10616  
             // com\\googlecode\\sparkleg\\SparqlT.g:326:7: ( propertyListNotEmptyDetails )+
 10617  0
             int cnt103=0;
 10618  
             loop103:
 10619  
             do {
 10620  0
                 int alt103=2;
 10621  0
                 switch ( input.LA(1) ) {
 10622  
                 case PREDICATE:
 10623  
                     {
 10624  0
                     alt103=1;
 10625  
                     }
 10626  
                     break;
 10627  
 
 10628  
                 }
 10629  
 
 10630  0
                 switch (alt103) {
 10631  
                     case 1 :
 10632  
                         // com\\googlecode\\sparkleg\\SparqlT.g:326:7: propertyListNotEmptyDetails
 10633  
                         {
 10634  0
                         _last = (CommonTree)input.LT(1);
 10635  0
                         pushFollow(FOLLOW_propertyListNotEmptyDetails_in_propertyListNotEmpty2139);
 10636  0
                         propertyListNotEmptyDetails267=propertyListNotEmptyDetails();
 10637  
 
 10638  0
                         state._fsp--;
 10639  
 
 10640  0
                         adaptor.addChild(root_0, propertyListNotEmptyDetails267.getTree());
 10641  
 
 10642  
 
 10643  
                         }
 10644  0
                         break;
 10645  
 
 10646  
                     default :
 10647  0
                         if ( cnt103 >= 1 ) break loop103;
 10648  0
                         EarlyExitException eee =
 10649  
                             new EarlyExitException(103, input);
 10650  0
                         throw eee;
 10651  
                 }
 10652  0
                 cnt103++;
 10653  0
             } while (true);
 10654  
 
 10655  
 
 10656  
             }
 10657  
 
 10658  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 10659  
 
 10660  
         }
 10661  0
         catch (RecognitionException re) {
 10662  0
             reportError(re);
 10663  0
             recover(input,re);
 10664  
         }
 10665  
 
 10666  0
         finally {
 10667  
                 // do for sure before leaving
 10668  0
         }
 10669  0
         return retval;
 10670  
     }
 10671  
     // $ANTLR end "propertyListNotEmpty"
 10672  
 
 10673  
 
 10674  0
     public static class propertyListNotEmptyDetails_return extends TreeRuleReturnScope {
 10675  
         CommonTree tree;
 10676  0
         public Object getTree() { return tree; }
 10677  
     };
 10678  
 
 10679  
 
 10680  
     // $ANTLR start "propertyListNotEmptyDetails"
 10681  
     // com\\googlecode\\sparkleg\\SparqlT.g:329:1: propertyListNotEmptyDetails : ^( PREDICATE v= verb o= objectList ) ;
 10682  
     public final SparqlT.propertyListNotEmptyDetails_return propertyListNotEmptyDetails() throws RecognitionException {
 10683  0
         SparqlT.propertyListNotEmptyDetails_return retval = new SparqlT.propertyListNotEmptyDetails_return();
 10684  0
         retval.start = input.LT(1);
 10685  
 
 10686  
 
 10687  0
         CommonTree root_0 = null;
 10688  
 
 10689  0
         CommonTree _first_0 = null;
 10690  0
         CommonTree _last = null;
 10691  
 
 10692  0
         CommonTree PREDICATE268=null;
 10693  0
         SparqlT.verb_return v =null;
 10694  
 
 10695  0
         SparqlT.objectList_return o =null;
 10696  
 
 10697  
 
 10698  0
         CommonTree PREDICATE268_tree=null;
 10699  
 
 10700  
         try {
 10701  
             // com\\googlecode\\sparkleg\\SparqlT.g:330:5: ( ^( PREDICATE v= verb o= objectList ) )
 10702  
             // com\\googlecode\\sparkleg\\SparqlT.g:330:7: ^( PREDICATE v= verb o= objectList )
 10703  
             {
 10704  0
             root_0 = (CommonTree)adaptor.nil();
 10705  
 
 10706  
 
 10707  0
             _last = (CommonTree)input.LT(1);
 10708  
             {
 10709  0
             CommonTree _save_last_1 = _last;
 10710  0
             CommonTree _first_1 = null;
 10711  0
             CommonTree root_1 = (CommonTree)adaptor.nil();
 10712  0
             _last = (CommonTree)input.LT(1);
 10713  0
             PREDICATE268=(CommonTree)match(input,PREDICATE,FOLLOW_PREDICATE_in_propertyListNotEmptyDetails2158); 
 10714  0
             PREDICATE268_tree = (CommonTree)adaptor.dupNode(PREDICATE268);
 10715  
 
 10716  
 
 10717  0
             root_1 = (CommonTree)adaptor.becomeRoot(PREDICATE268_tree, root_1);
 10718  
 
 10719  
 
 10720  0
             match(input, Token.DOWN, null); 
 10721  0
             _last = (CommonTree)input.LT(1);
 10722  0
             pushFollow(FOLLOW_verb_in_propertyListNotEmptyDetails2163);
 10723  0
             v=verb();
 10724  
 
 10725  0
             state._fsp--;
 10726  
 
 10727  0
             adaptor.addChild(root_1, v.getTree());
 10728  
 
 10729  
 
 10730  0
             _last = (CommonTree)input.LT(1);
 10731  0
             pushFollow(FOLLOW_objectList_in_propertyListNotEmptyDetails2167);
 10732  0
             o=objectList();
 10733  
 
 10734  0
             state._fsp--;
 10735  
 
 10736  0
             adaptor.addChild(root_1, o.getTree());
 10737  
 
 10738  
 
 10739  0
             match(input, Token.UP, null); 
 10740  0
             adaptor.addChild(root_0, root_1);
 10741  0
             _last = _save_last_1;
 10742  
             }
 10743  
 
 10744  
 
 10745  
             }
 10746  
 
 10747  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 10748  
 
 10749  
         }
 10750  0
         catch (RecognitionException re) {
 10751  0
             reportError(re);
 10752  0
             recover(input,re);
 10753  
         }
 10754  
 
 10755  0
         finally {
 10756  
                 // do for sure before leaving
 10757  0
         }
 10758  0
         return retval;
 10759  
     }
 10760  
     // $ANTLR end "propertyListNotEmptyDetails"
 10761  
 
 10762  
 
 10763  0
     public static class objectList_return extends TreeRuleReturnScope {
 10764  
         CommonTree tree;
 10765  0
         public Object getTree() { return tree; }
 10766  
     };
 10767  
 
 10768  
 
 10769  
     // $ANTLR start "objectList"
 10770  
     // com\\googlecode\\sparkleg\\SparqlT.g:333:1: objectList : ( ^( OBJECT graphNode ) )+ ;
 10771  
     public final SparqlT.objectList_return objectList() throws RecognitionException {
 10772  0
         SparqlT.objectList_return retval = new SparqlT.objectList_return();
 10773  0
         retval.start = input.LT(1);
 10774  
 
 10775  
 
 10776  0
         CommonTree root_0 = null;
 10777  
 
 10778  0
         CommonTree _first_0 = null;
 10779  0
         CommonTree _last = null;
 10780  
 
 10781  0
         CommonTree OBJECT269=null;
 10782  0
         SparqlT.graphNode_return graphNode270 =null;
 10783  
 
 10784  
 
 10785  0
         CommonTree OBJECT269_tree=null;
 10786  
 
 10787  
         try {
 10788  
             // com\\googlecode\\sparkleg\\SparqlT.g:334:5: ( ( ^( OBJECT graphNode ) )+ )
 10789  
             // com\\googlecode\\sparkleg\\SparqlT.g:334:7: ( ^( OBJECT graphNode ) )+
 10790  
             {
 10791  0
             root_0 = (CommonTree)adaptor.nil();
 10792  
 
 10793  
 
 10794  
             // com\\googlecode\\sparkleg\\SparqlT.g:334:7: ( ^( OBJECT graphNode ) )+
 10795  0
             int cnt104=0;
 10796  
             loop104:
 10797  
             do {
 10798  0
                 int alt104=2;
 10799  0
                 switch ( input.LA(1) ) {
 10800  
                 case OBJECT:
 10801  
                     {
 10802  0
                     alt104=1;
 10803  
                     }
 10804  
                     break;
 10805  
 
 10806  
                 }
 10807  
 
 10808  0
                 switch (alt104) {
 10809  
                     case 1 :
 10810  
                         // com\\googlecode\\sparkleg\\SparqlT.g:334:8: ^( OBJECT graphNode )
 10811  
                         {
 10812  0
                         _last = (CommonTree)input.LT(1);
 10813  
                         {
 10814  0
                         CommonTree _save_last_1 = _last;
 10815  0
                         CommonTree _first_1 = null;
 10816  0
                         CommonTree root_1 = (CommonTree)adaptor.nil();
 10817  0
                         _last = (CommonTree)input.LT(1);
 10818  0
                         OBJECT269=(CommonTree)match(input,OBJECT,FOLLOW_OBJECT_in_objectList2187); 
 10819  0
                         OBJECT269_tree = (CommonTree)adaptor.dupNode(OBJECT269);
 10820  
 
 10821  
 
 10822  0
                         root_1 = (CommonTree)adaptor.becomeRoot(OBJECT269_tree, root_1);
 10823  
 
 10824  
 
 10825  0
                         match(input, Token.DOWN, null); 
 10826  0
                         _last = (CommonTree)input.LT(1);
 10827  0
                         pushFollow(FOLLOW_graphNode_in_objectList2189);
 10828  0
                         graphNode270=graphNode();
 10829  
 
 10830  0
                         state._fsp--;
 10831  
 
 10832  0
                         adaptor.addChild(root_1, graphNode270.getTree());
 10833  
 
 10834  
 
 10835  0
                         match(input, Token.UP, null); 
 10836  0
                         adaptor.addChild(root_0, root_1);
 10837  0
                         _last = _save_last_1;
 10838  
                         }
 10839  
 
 10840  
 
 10841  
                         }
 10842  0
                         break;
 10843  
 
 10844  
                     default :
 10845  0
                         if ( cnt104 >= 1 ) break loop104;
 10846  0
                         EarlyExitException eee =
 10847  
                             new EarlyExitException(104, input);
 10848  0
                         throw eee;
 10849  
                 }
 10850  0
                 cnt104++;
 10851  0
             } while (true);
 10852  
 
 10853  
 
 10854  
             }
 10855  
 
 10856  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 10857  
 
 10858  
         }
 10859  0
         catch (RecognitionException re) {
 10860  0
             reportError(re);
 10861  0
             recover(input,re);
 10862  
         }
 10863  
 
 10864  0
         finally {
 10865  
                 // do for sure before leaving
 10866  0
         }
 10867  0
         return retval;
 10868  
     }
 10869  
     // $ANTLR end "objectList"
 10870  
 
 10871  
 
 10872  0
     public static class verb_return extends TreeRuleReturnScope {
 10873  
         CommonTree tree;
 10874  0
         public Object getTree() { return tree; }
 10875  
     };
 10876  
 
 10877  
 
 10878  
     // $ANTLR start "verb"
 10879  
     // com\\googlecode\\sparkleg\\SparqlT.g:337:1: verb : ( varOrIRIref | A | path );
 10880  
     public final SparqlT.verb_return verb() throws RecognitionException {
 10881  0
         SparqlT.verb_return retval = new SparqlT.verb_return();
 10882  0
         retval.start = input.LT(1);
 10883  
 
 10884  
 
 10885  0
         CommonTree root_0 = null;
 10886  
 
 10887  0
         CommonTree _first_0 = null;
 10888  0
         CommonTree _last = null;
 10889  
 
 10890  0
         CommonTree A272=null;
 10891  0
         SparqlT.varOrIRIref_return varOrIRIref271 =null;
 10892  
 
 10893  0
         SparqlT.path_return path273 =null;
 10894  
 
 10895  
 
 10896  0
         CommonTree A272_tree=null;
 10897  
 
 10898  
         try {
 10899  
             // com\\googlecode\\sparkleg\\SparqlT.g:338:5: ( varOrIRIref | A | path )
 10900  0
             int alt105=3;
 10901  0
             switch ( input.LA(1) ) {
 10902  
             case IRI_REF:
 10903  
             case PNAME_LN:
 10904  
             case PNAME_NS:
 10905  
             case VAR1:
 10906  
             case VAR2:
 10907  
                 {
 10908  0
                 alt105=1;
 10909  
                 }
 10910  0
                 break;
 10911  
             case A:
 10912  
                 {
 10913  0
                 alt105=2;
 10914  
                 }
 10915  0
                 break;
 10916  
             case PATH:
 10917  
                 {
 10918  0
                 alt105=3;
 10919  
                 }
 10920  0
                 break;
 10921  
             default:
 10922  0
                 NoViableAltException nvae =
 10923  
                     new NoViableAltException("", 105, 0, input);
 10924  
 
 10925  0
                 throw nvae;
 10926  
 
 10927  
             }
 10928  
 
 10929  0
             switch (alt105) {
 10930  
                 case 1 :
 10931  
                     // com\\googlecode\\sparkleg\\SparqlT.g:338:7: varOrIRIref
 10932  
                     {
 10933  0
                     root_0 = (CommonTree)adaptor.nil();
 10934  
 
 10935  
 
 10936  0
                     _last = (CommonTree)input.LT(1);
 10937  0
                     pushFollow(FOLLOW_varOrIRIref_in_verb2209);
 10938  0
                     varOrIRIref271=varOrIRIref();
 10939  
 
 10940  0
                     state._fsp--;
 10941  
 
 10942  0
                     adaptor.addChild(root_0, varOrIRIref271.getTree());
 10943  
 
 10944  
 
 10945  
                     }
 10946  0
                     break;
 10947  
                 case 2 :
 10948  
                     // com\\googlecode\\sparkleg\\SparqlT.g:339:7: A
 10949  
                     {
 10950  0
                     root_0 = (CommonTree)adaptor.nil();
 10951  
 
 10952  
 
 10953  0
                     _last = (CommonTree)input.LT(1);
 10954  0
                     A272=(CommonTree)match(input,A,FOLLOW_A_in_verb2217); 
 10955  0
                     A272_tree = (CommonTree)adaptor.dupNode(A272);
 10956  
 
 10957  
 
 10958  0
                     adaptor.addChild(root_0, A272_tree);
 10959  
 
 10960  
 
 10961  
                     }
 10962  0
                     break;
 10963  
                 case 3 :
 10964  
                     // com\\googlecode\\sparkleg\\SparqlT.g:340:7: path
 10965  
                     {
 10966  0
                     root_0 = (CommonTree)adaptor.nil();
 10967  
 
 10968  
 
 10969  0
                     _last = (CommonTree)input.LT(1);
 10970  0
                     pushFollow(FOLLOW_path_in_verb2225);
 10971  0
                     path273=path();
 10972  
 
 10973  0
                     state._fsp--;
 10974  
 
 10975  0
                     adaptor.addChild(root_0, path273.getTree());
 10976  
 
 10977  
 
 10978  
                     }
 10979  
                     break;
 10980  
 
 10981  
             }
 10982  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 10983  
 
 10984  
         }
 10985  0
         catch (RecognitionException re) {
 10986  0
             reportError(re);
 10987  0
             recover(input,re);
 10988  
         }
 10989  
 
 10990  0
         finally {
 10991  
                 // do for sure before leaving
 10992  0
         }
 10993  0
         return retval;
 10994  
     }
 10995  
     // $ANTLR end "verb"
 10996  
 
 10997  
 
 10998  0
     public static class triplesSameSubjectPath_return extends TreeRuleReturnScope {
 10999  
         CommonTree tree;
 11000  0
         public Object getTree() { return tree; }
 11001  
     };
 11002  
 
 11003  
 
 11004  
     // $ANTLR start "triplesSameSubjectPath"
 11005  
     // com\\googlecode\\sparkleg\\SparqlT.g:343:1: triplesSameSubjectPath : ( ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) propertyListNotEmpty ) | ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? ) );
 11006  
     public final SparqlT.triplesSameSubjectPath_return triplesSameSubjectPath() throws RecognitionException {
 11007  0
         SparqlT.triplesSameSubjectPath_return retval = new SparqlT.triplesSameSubjectPath_return();
 11008  0
         retval.start = input.LT(1);
 11009  
 
 11010  
 
 11011  0
         CommonTree root_0 = null;
 11012  
 
 11013  0
         CommonTree _first_0 = null;
 11014  0
         CommonTree _last = null;
 11015  
 
 11016  0
         CommonTree TRIPLES_SAME_SUBJECT274=null;
 11017  0
         CommonTree SUBJECT275=null;
 11018  0
         CommonTree TRIPLES_SAME_SUBJECT278=null;
 11019  0
         SparqlT.varOrTerm_return varOrTerm276 =null;
 11020  
 
 11021  0
         SparqlT.propertyListNotEmpty_return propertyListNotEmpty277 =null;
 11022  
 
 11023  0
         SparqlT.triplesNode_return triplesNode279 =null;
 11024  
 
 11025  0
         SparqlT.propertyListNotEmpty_return propertyListNotEmpty280 =null;
 11026  
 
 11027  
 
 11028  0
         CommonTree TRIPLES_SAME_SUBJECT274_tree=null;
 11029  0
         CommonTree SUBJECT275_tree=null;
 11030  0
         CommonTree TRIPLES_SAME_SUBJECT278_tree=null;
 11031  
 
 11032  
         try {
 11033  
             // com\\googlecode\\sparkleg\\SparqlT.g:344:5: ( ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) propertyListNotEmpty ) | ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? ) )
 11034  0
             int alt107=2;
 11035  0
             switch ( input.LA(1) ) {
 11036  
             case TRIPLES_SAME_SUBJECT:
 11037  
                 {
 11038  0
                 switch ( input.LA(2) ) {
 11039  
                 case DOWN:
 11040  
                     {
 11041  0
                     switch ( input.LA(3) ) {
 11042  
                     case SUBJECT:
 11043  
                         {
 11044  0
                         alt107=1;
 11045  
                         }
 11046  0
                         break;
 11047  
                     case COLLECTION:
 11048  
                     case TRIPLES_NODE:
 11049  
                         {
 11050  0
                         alt107=2;
 11051  
                         }
 11052  0
                         break;
 11053  
                     default:
 11054  0
                         NoViableAltException nvae =
 11055  
                             new NoViableAltException("", 107, 2, input);
 11056  
 
 11057  0
                         throw nvae;
 11058  
 
 11059  
                     }
 11060  
 
 11061  
                     }
 11062  0
                     break;
 11063  
                 default:
 11064  0
                     NoViableAltException nvae =
 11065  
                         new NoViableAltException("", 107, 1, input);
 11066  
 
 11067  0
                     throw nvae;
 11068  
 
 11069  
                 }
 11070  
 
 11071  
                 }
 11072  0
                 break;
 11073  
             default:
 11074  0
                 NoViableAltException nvae =
 11075  
                     new NoViableAltException("", 107, 0, input);
 11076  
 
 11077  0
                 throw nvae;
 11078  
 
 11079  
             }
 11080  
 
 11081  0
             switch (alt107) {
 11082  
                 case 1 :
 11083  
                     // com\\googlecode\\sparkleg\\SparqlT.g:344:7: ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) propertyListNotEmpty )
 11084  
                     {
 11085  0
                     root_0 = (CommonTree)adaptor.nil();
 11086  
 
 11087  
 
 11088  0
                     _last = (CommonTree)input.LT(1);
 11089  
                     {
 11090  0
                     CommonTree _save_last_1 = _last;
 11091  0
                     CommonTree _first_1 = null;
 11092  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 11093  0
                     _last = (CommonTree)input.LT(1);
 11094  0
                     TRIPLES_SAME_SUBJECT274=(CommonTree)match(input,TRIPLES_SAME_SUBJECT,FOLLOW_TRIPLES_SAME_SUBJECT_in_triplesSameSubjectPath2243); 
 11095  0
                     TRIPLES_SAME_SUBJECT274_tree = (CommonTree)adaptor.dupNode(TRIPLES_SAME_SUBJECT274);
 11096  
 
 11097  
 
 11098  0
                     root_1 = (CommonTree)adaptor.becomeRoot(TRIPLES_SAME_SUBJECT274_tree, root_1);
 11099  
 
 11100  
 
 11101  0
                     match(input, Token.DOWN, null); 
 11102  0
                     _last = (CommonTree)input.LT(1);
 11103  
                     {
 11104  0
                     CommonTree _save_last_2 = _last;
 11105  0
                     CommonTree _first_2 = null;
 11106  0
                     CommonTree root_2 = (CommonTree)adaptor.nil();
 11107  0
                     _last = (CommonTree)input.LT(1);
 11108  0
                     SUBJECT275=(CommonTree)match(input,SUBJECT,FOLLOW_SUBJECT_in_triplesSameSubjectPath2246); 
 11109  0
                     SUBJECT275_tree = (CommonTree)adaptor.dupNode(SUBJECT275);
 11110  
 
 11111  
 
 11112  0
                     root_2 = (CommonTree)adaptor.becomeRoot(SUBJECT275_tree, root_2);
 11113  
 
 11114  
 
 11115  0
                     match(input, Token.DOWN, null); 
 11116  0
                     _last = (CommonTree)input.LT(1);
 11117  0
                     pushFollow(FOLLOW_varOrTerm_in_triplesSameSubjectPath2248);
 11118  0
                     varOrTerm276=varOrTerm();
 11119  
 
 11120  0
                     state._fsp--;
 11121  
 
 11122  0
                     adaptor.addChild(root_2, varOrTerm276.getTree());
 11123  
 
 11124  
 
 11125  0
                     match(input, Token.UP, null); 
 11126  0
                     adaptor.addChild(root_1, root_2);
 11127  0
                     _last = _save_last_2;
 11128  
                     }
 11129  
 
 11130  
 
 11131  0
                     _last = (CommonTree)input.LT(1);
 11132  0
                     pushFollow(FOLLOW_propertyListNotEmpty_in_triplesSameSubjectPath2251);
 11133  0
                     propertyListNotEmpty277=propertyListNotEmpty();
 11134  
 
 11135  0
                     state._fsp--;
 11136  
 
 11137  0
                     adaptor.addChild(root_1, propertyListNotEmpty277.getTree());
 11138  
 
 11139  
 
 11140  0
                     match(input, Token.UP, null); 
 11141  0
                     adaptor.addChild(root_0, root_1);
 11142  0
                     _last = _save_last_1;
 11143  
                     }
 11144  
 
 11145  
 
 11146  
                     }
 11147  0
                     break;
 11148  
                 case 2 :
 11149  
                     // com\\googlecode\\sparkleg\\SparqlT.g:345:7: ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? )
 11150  
                     {
 11151  0
                     root_0 = (CommonTree)adaptor.nil();
 11152  
 
 11153  
 
 11154  0
                     _last = (CommonTree)input.LT(1);
 11155  
                     {
 11156  0
                     CommonTree _save_last_1 = _last;
 11157  0
                     CommonTree _first_1 = null;
 11158  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 11159  0
                     _last = (CommonTree)input.LT(1);
 11160  0
                     TRIPLES_SAME_SUBJECT278=(CommonTree)match(input,TRIPLES_SAME_SUBJECT,FOLLOW_TRIPLES_SAME_SUBJECT_in_triplesSameSubjectPath2261); 
 11161  0
                     TRIPLES_SAME_SUBJECT278_tree = (CommonTree)adaptor.dupNode(TRIPLES_SAME_SUBJECT278);
 11162  
 
 11163  
 
 11164  0
                     root_1 = (CommonTree)adaptor.becomeRoot(TRIPLES_SAME_SUBJECT278_tree, root_1);
 11165  
 
 11166  
 
 11167  0
                     match(input, Token.DOWN, null); 
 11168  0
                     _last = (CommonTree)input.LT(1);
 11169  0
                     pushFollow(FOLLOW_triplesNode_in_triplesSameSubjectPath2264);
 11170  0
                     triplesNode279=triplesNode();
 11171  
 
 11172  0
                     state._fsp--;
 11173  
 
 11174  0
                     adaptor.addChild(root_1, triplesNode279.getTree());
 11175  
 
 11176  
 
 11177  
                     // com\\googlecode\\sparkleg\\SparqlT.g:345:43: ( propertyListNotEmpty )?
 11178  0
                     int alt106=2;
 11179  0
                     switch ( input.LA(1) ) {
 11180  
                         case PREDICATE:
 11181  
                             {
 11182  0
                             alt106=1;
 11183  
                             }
 11184  
                             break;
 11185  
                     }
 11186  
 
 11187  0
                     switch (alt106) {
 11188  
                         case 1 :
 11189  
                             // com\\googlecode\\sparkleg\\SparqlT.g:345:43: propertyListNotEmpty
 11190  
                             {
 11191  0
                             _last = (CommonTree)input.LT(1);
 11192  0
                             pushFollow(FOLLOW_propertyListNotEmpty_in_triplesSameSubjectPath2266);
 11193  0
                             propertyListNotEmpty280=propertyListNotEmpty();
 11194  
 
 11195  0
                             state._fsp--;
 11196  
 
 11197  0
                             adaptor.addChild(root_1, propertyListNotEmpty280.getTree());
 11198  
 
 11199  
 
 11200  
                             }
 11201  
                             break;
 11202  
 
 11203  
                     }
 11204  
 
 11205  
 
 11206  0
                     match(input, Token.UP, null); 
 11207  0
                     adaptor.addChild(root_0, root_1);
 11208  0
                     _last = _save_last_1;
 11209  
                     }
 11210  
 
 11211  
 
 11212  
                     }
 11213  
                     break;
 11214  
 
 11215  
             }
 11216  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 11217  
 
 11218  
         }
 11219  0
         catch (RecognitionException re) {
 11220  0
             reportError(re);
 11221  0
             recover(input,re);
 11222  
         }
 11223  
 
 11224  0
         finally {
 11225  
                 // do for sure before leaving
 11226  0
         }
 11227  0
         return retval;
 11228  
     }
 11229  
     // $ANTLR end "triplesSameSubjectPath"
 11230  
 
 11231  
 
 11232  0
     public static class path_return extends TreeRuleReturnScope {
 11233  
         CommonTree tree;
 11234  0
         public Object getTree() { return tree; }
 11235  
     };
 11236  
 
 11237  
 
 11238  
     // $ANTLR start "path"
 11239  
     // com\\googlecode\\sparkleg\\SparqlT.g:348:1: path : ^( PATH ( pathSequence )+ ) ;
 11240  
     public final SparqlT.path_return path() throws RecognitionException {
 11241  0
         SparqlT.path_return retval = new SparqlT.path_return();
 11242  0
         retval.start = input.LT(1);
 11243  
 
 11244  
 
 11245  0
         CommonTree root_0 = null;
 11246  
 
 11247  0
         CommonTree _first_0 = null;
 11248  0
         CommonTree _last = null;
 11249  
 
 11250  0
         CommonTree PATH281=null;
 11251  0
         SparqlT.pathSequence_return pathSequence282 =null;
 11252  
 
 11253  
 
 11254  0
         CommonTree PATH281_tree=null;
 11255  
 
 11256  
         try {
 11257  
             // com\\googlecode\\sparkleg\\SparqlT.g:349:5: ( ^( PATH ( pathSequence )+ ) )
 11258  
             // com\\googlecode\\sparkleg\\SparqlT.g:349:7: ^( PATH ( pathSequence )+ )
 11259  
             {
 11260  0
             root_0 = (CommonTree)adaptor.nil();
 11261  
 
 11262  
 
 11263  0
             _last = (CommonTree)input.LT(1);
 11264  
             {
 11265  0
             CommonTree _save_last_1 = _last;
 11266  0
             CommonTree _first_1 = null;
 11267  0
             CommonTree root_1 = (CommonTree)adaptor.nil();
 11268  0
             _last = (CommonTree)input.LT(1);
 11269  0
             PATH281=(CommonTree)match(input,PATH,FOLLOW_PATH_in_path2290); 
 11270  0
             PATH281_tree = (CommonTree)adaptor.dupNode(PATH281);
 11271  
 
 11272  
 
 11273  0
             root_1 = (CommonTree)adaptor.becomeRoot(PATH281_tree, root_1);
 11274  
 
 11275  
 
 11276  0
             match(input, Token.DOWN, null); 
 11277  
             // com\\googlecode\\sparkleg\\SparqlT.g:349:14: ( pathSequence )+
 11278  0
             int cnt108=0;
 11279  
             loop108:
 11280  
             do {
 11281  0
                 int alt108=2;
 11282  0
                 switch ( input.LA(1) ) {
 11283  
                 case PATH_SEQUENCE:
 11284  
                     {
 11285  0
                     alt108=1;
 11286  
                     }
 11287  
                     break;
 11288  
 
 11289  
                 }
 11290  
 
 11291  0
                 switch (alt108) {
 11292  
                     case 1 :
 11293  
                         // com\\googlecode\\sparkleg\\SparqlT.g:349:14: pathSequence
 11294  
                         {
 11295  0
                         _last = (CommonTree)input.LT(1);
 11296  0
                         pushFollow(FOLLOW_pathSequence_in_path2292);
 11297  0
                         pathSequence282=pathSequence();
 11298  
 
 11299  0
                         state._fsp--;
 11300  
 
 11301  0
                         adaptor.addChild(root_1, pathSequence282.getTree());
 11302  
 
 11303  
 
 11304  
                         }
 11305  0
                         break;
 11306  
 
 11307  
                     default :
 11308  0
                         if ( cnt108 >= 1 ) break loop108;
 11309  0
                         EarlyExitException eee =
 11310  
                             new EarlyExitException(108, input);
 11311  0
                         throw eee;
 11312  
                 }
 11313  0
                 cnt108++;
 11314  0
             } while (true);
 11315  
 
 11316  
 
 11317  0
             match(input, Token.UP, null); 
 11318  0
             adaptor.addChild(root_0, root_1);
 11319  0
             _last = _save_last_1;
 11320  
             }
 11321  
 
 11322  
 
 11323  
             }
 11324  
 
 11325  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 11326  
 
 11327  
         }
 11328  0
         catch (RecognitionException re) {
 11329  0
             reportError(re);
 11330  0
             recover(input,re);
 11331  
         }
 11332  
 
 11333  0
         finally {
 11334  
                 // do for sure before leaving
 11335  0
         }
 11336  0
         return retval;
 11337  
     }
 11338  
     // $ANTLR end "path"
 11339  
 
 11340  
 
 11341  0
     public static class pathSequence_return extends TreeRuleReturnScope {
 11342  
         CommonTree tree;
 11343  0
         public Object getTree() { return tree; }
 11344  
     };
 11345  
 
 11346  
 
 11347  
     // $ANTLR start "pathSequence"
 11348  
     // com\\googlecode\\sparkleg\\SparqlT.g:352:1: pathSequence : ^( PATH_SEQUENCE ( pathEltOrInverse )+ ) ;
 11349  
     public final SparqlT.pathSequence_return pathSequence() throws RecognitionException {
 11350  0
         SparqlT.pathSequence_return retval = new SparqlT.pathSequence_return();
 11351  0
         retval.start = input.LT(1);
 11352  
 
 11353  
 
 11354  0
         CommonTree root_0 = null;
 11355  
 
 11356  0
         CommonTree _first_0 = null;
 11357  0
         CommonTree _last = null;
 11358  
 
 11359  0
         CommonTree PATH_SEQUENCE283=null;
 11360  0
         SparqlT.pathEltOrInverse_return pathEltOrInverse284 =null;
 11361  
 
 11362  
 
 11363  0
         CommonTree PATH_SEQUENCE283_tree=null;
 11364  
 
 11365  
         try {
 11366  
             // com\\googlecode\\sparkleg\\SparqlT.g:353:5: ( ^( PATH_SEQUENCE ( pathEltOrInverse )+ ) )
 11367  
             // com\\googlecode\\sparkleg\\SparqlT.g:353:7: ^( PATH_SEQUENCE ( pathEltOrInverse )+ )
 11368  
             {
 11369  0
             root_0 = (CommonTree)adaptor.nil();
 11370  
 
 11371  
 
 11372  0
             _last = (CommonTree)input.LT(1);
 11373  
             {
 11374  0
             CommonTree _save_last_1 = _last;
 11375  0
             CommonTree _first_1 = null;
 11376  0
             CommonTree root_1 = (CommonTree)adaptor.nil();
 11377  0
             _last = (CommonTree)input.LT(1);
 11378  0
             PATH_SEQUENCE283=(CommonTree)match(input,PATH_SEQUENCE,FOLLOW_PATH_SEQUENCE_in_pathSequence2313); 
 11379  0
             PATH_SEQUENCE283_tree = (CommonTree)adaptor.dupNode(PATH_SEQUENCE283);
 11380  
 
 11381  
 
 11382  0
             root_1 = (CommonTree)adaptor.becomeRoot(PATH_SEQUENCE283_tree, root_1);
 11383  
 
 11384  
 
 11385  0
             match(input, Token.DOWN, null); 
 11386  
             // com\\googlecode\\sparkleg\\SparqlT.g:353:23: ( pathEltOrInverse )+
 11387  0
             int cnt109=0;
 11388  
             loop109:
 11389  
             do {
 11390  0
                 int alt109=2;
 11391  0
                 switch ( input.LA(1) ) {
 11392  
                 case INVERSE:
 11393  
                 case PATH_PRIMARY:
 11394  
                     {
 11395  0
                     alt109=1;
 11396  
                     }
 11397  
                     break;
 11398  
 
 11399  
                 }
 11400  
 
 11401  0
                 switch (alt109) {
 11402  
                     case 1 :
 11403  
                         // com\\googlecode\\sparkleg\\SparqlT.g:353:23: pathEltOrInverse
 11404  
                         {
 11405  0
                         _last = (CommonTree)input.LT(1);
 11406  0
                         pushFollow(FOLLOW_pathEltOrInverse_in_pathSequence2315);
 11407  0
                         pathEltOrInverse284=pathEltOrInverse();
 11408  
 
 11409  0
                         state._fsp--;
 11410  
 
 11411  0
                         adaptor.addChild(root_1, pathEltOrInverse284.getTree());
 11412  
 
 11413  
 
 11414  
                         }
 11415  0
                         break;
 11416  
 
 11417  
                     default :
 11418  0
                         if ( cnt109 >= 1 ) break loop109;
 11419  0
                         EarlyExitException eee =
 11420  
                             new EarlyExitException(109, input);
 11421  0
                         throw eee;
 11422  
                 }
 11423  0
                 cnt109++;
 11424  0
             } while (true);
 11425  
 
 11426  
 
 11427  0
             match(input, Token.UP, null); 
 11428  0
             adaptor.addChild(root_0, root_1);
 11429  0
             _last = _save_last_1;
 11430  
             }
 11431  
 
 11432  
 
 11433  
             }
 11434  
 
 11435  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 11436  
 
 11437  
         }
 11438  0
         catch (RecognitionException re) {
 11439  0
             reportError(re);
 11440  0
             recover(input,re);
 11441  
         }
 11442  
 
 11443  0
         finally {
 11444  
                 // do for sure before leaving
 11445  0
         }
 11446  0
         return retval;
 11447  
     }
 11448  
     // $ANTLR end "pathSequence"
 11449  
 
 11450  
 
 11451  0
     public static class pathEltOrInverse_return extends TreeRuleReturnScope {
 11452  
         CommonTree tree;
 11453  0
         public Object getTree() { return tree; }
 11454  
     };
 11455  
 
 11456  
 
 11457  
     // $ANTLR start "pathEltOrInverse"
 11458  
     // com\\googlecode\\sparkleg\\SparqlT.g:356:1: pathEltOrInverse : ( INVERSE )? pathElt ;
 11459  
     public final SparqlT.pathEltOrInverse_return pathEltOrInverse() throws RecognitionException {
 11460  0
         SparqlT.pathEltOrInverse_return retval = new SparqlT.pathEltOrInverse_return();
 11461  0
         retval.start = input.LT(1);
 11462  
 
 11463  
 
 11464  0
         CommonTree root_0 = null;
 11465  
 
 11466  0
         CommonTree _first_0 = null;
 11467  0
         CommonTree _last = null;
 11468  
 
 11469  0
         CommonTree INVERSE285=null;
 11470  0
         SparqlT.pathElt_return pathElt286 =null;
 11471  
 
 11472  
 
 11473  0
         CommonTree INVERSE285_tree=null;
 11474  
 
 11475  
         try {
 11476  
             // com\\googlecode\\sparkleg\\SparqlT.g:357:5: ( ( INVERSE )? pathElt )
 11477  
             // com\\googlecode\\sparkleg\\SparqlT.g:357:7: ( INVERSE )? pathElt
 11478  
             {
 11479  0
             root_0 = (CommonTree)adaptor.nil();
 11480  
 
 11481  
 
 11482  
             // com\\googlecode\\sparkleg\\SparqlT.g:357:7: ( INVERSE )?
 11483  0
             int alt110=2;
 11484  0
             switch ( input.LA(1) ) {
 11485  
                 case INVERSE:
 11486  
                     {
 11487  0
                     alt110=1;
 11488  
                     }
 11489  
                     break;
 11490  
             }
 11491  
 
 11492  0
             switch (alt110) {
 11493  
                 case 1 :
 11494  
                     // com\\googlecode\\sparkleg\\SparqlT.g:357:7: INVERSE
 11495  
                     {
 11496  0
                     _last = (CommonTree)input.LT(1);
 11497  0
                     INVERSE285=(CommonTree)match(input,INVERSE,FOLLOW_INVERSE_in_pathEltOrInverse2338); 
 11498  0
                     INVERSE285_tree = (CommonTree)adaptor.dupNode(INVERSE285);
 11499  
 
 11500  
 
 11501  0
                     adaptor.addChild(root_0, INVERSE285_tree);
 11502  
 
 11503  
 
 11504  
                     }
 11505  
                     break;
 11506  
 
 11507  
             }
 11508  
 
 11509  
 
 11510  0
             _last = (CommonTree)input.LT(1);
 11511  0
             pushFollow(FOLLOW_pathElt_in_pathEltOrInverse2341);
 11512  0
             pathElt286=pathElt();
 11513  
 
 11514  0
             state._fsp--;
 11515  
 
 11516  0
             adaptor.addChild(root_0, pathElt286.getTree());
 11517  
 
 11518  
 
 11519  
             }
 11520  
 
 11521  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 11522  
 
 11523  
         }
 11524  0
         catch (RecognitionException re) {
 11525  0
             reportError(re);
 11526  0
             recover(input,re);
 11527  
         }
 11528  
 
 11529  0
         finally {
 11530  
                 // do for sure before leaving
 11531  0
         }
 11532  0
         return retval;
 11533  
     }
 11534  
     // $ANTLR end "pathEltOrInverse"
 11535  
 
 11536  
 
 11537  0
     public static class pathElt_return extends TreeRuleReturnScope {
 11538  
         CommonTree tree;
 11539  0
         public Object getTree() { return tree; }
 11540  
     };
 11541  
 
 11542  
 
 11543  
     // $ANTLR start "pathElt"
 11544  
     // com\\googlecode\\sparkleg\\SparqlT.g:360:1: pathElt : pathPrimary ( pathMod )? ;
 11545  
     public final SparqlT.pathElt_return pathElt() throws RecognitionException {
 11546  0
         SparqlT.pathElt_return retval = new SparqlT.pathElt_return();
 11547  0
         retval.start = input.LT(1);
 11548  
 
 11549  
 
 11550  0
         CommonTree root_0 = null;
 11551  
 
 11552  0
         CommonTree _first_0 = null;
 11553  0
         CommonTree _last = null;
 11554  
 
 11555  0
         SparqlT.pathPrimary_return pathPrimary287 =null;
 11556  
 
 11557  0
         SparqlT.pathMod_return pathMod288 =null;
 11558  
 
 11559  
 
 11560  
 
 11561  
         try {
 11562  
             // com\\googlecode\\sparkleg\\SparqlT.g:361:5: ( pathPrimary ( pathMod )? )
 11563  
             // com\\googlecode\\sparkleg\\SparqlT.g:361:7: pathPrimary ( pathMod )?
 11564  
             {
 11565  0
             root_0 = (CommonTree)adaptor.nil();
 11566  
 
 11567  
 
 11568  0
             _last = (CommonTree)input.LT(1);
 11569  0
             pushFollow(FOLLOW_pathPrimary_in_pathElt2366);
 11570  0
             pathPrimary287=pathPrimary();
 11571  
 
 11572  0
             state._fsp--;
 11573  
 
 11574  0
             adaptor.addChild(root_0, pathPrimary287.getTree());
 11575  
 
 11576  
 
 11577  
             // com\\googlecode\\sparkleg\\SparqlT.g:361:19: ( pathMod )?
 11578  0
             int alt111=2;
 11579  0
             switch ( input.LA(1) ) {
 11580  
                 case ASTERISK:
 11581  
                 case OPEN_CURLY_BRACE:
 11582  
                 case PLUS:
 11583  
                 case QUESTION_MARK:
 11584  
                     {
 11585  0
                     alt111=1;
 11586  
                     }
 11587  
                     break;
 11588  
             }
 11589  
 
 11590  0
             switch (alt111) {
 11591  
                 case 1 :
 11592  
                     // com\\googlecode\\sparkleg\\SparqlT.g:361:19: pathMod
 11593  
                     {
 11594  0
                     _last = (CommonTree)input.LT(1);
 11595  0
                     pushFollow(FOLLOW_pathMod_in_pathElt2368);
 11596  0
                     pathMod288=pathMod();
 11597  
 
 11598  0
                     state._fsp--;
 11599  
 
 11600  0
                     adaptor.addChild(root_0, pathMod288.getTree());
 11601  
 
 11602  
 
 11603  
                     }
 11604  
                     break;
 11605  
 
 11606  
             }
 11607  
 
 11608  
 
 11609  
             }
 11610  
 
 11611  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 11612  
 
 11613  
         }
 11614  0
         catch (RecognitionException re) {
 11615  0
             reportError(re);
 11616  0
             recover(input,re);
 11617  
         }
 11618  
 
 11619  0
         finally {
 11620  
                 // do for sure before leaving
 11621  0
         }
 11622  0
         return retval;
 11623  
     }
 11624  
     // $ANTLR end "pathElt"
 11625  
 
 11626  
 
 11627  0
     public static class pathMod_return extends TreeRuleReturnScope {
 11628  
         CommonTree tree;
 11629  0
         public Object getTree() { return tree; }
 11630  
     };
 11631  
 
 11632  
 
 11633  
     // $ANTLR start "pathMod"
 11634  
     // com\\googlecode\\sparkleg\\SparqlT.g:364:1: pathMod : ( ASTERISK | QUESTION_MARK | PLUS | OPEN_CURLY_BRACE ( INTEGER ( COMMA ( CLOSE_CURLY_BRACE | INTEGER CLOSE_CURLY_BRACE ) | CLOSE_CURLY_BRACE ) | COMMA INTEGER CLOSE_CURLY_BRACE ) ) ;
 11635  
     public final SparqlT.pathMod_return pathMod() throws RecognitionException {
 11636  0
         SparqlT.pathMod_return retval = new SparqlT.pathMod_return();
 11637  0
         retval.start = input.LT(1);
 11638  
 
 11639  
 
 11640  0
         CommonTree root_0 = null;
 11641  
 
 11642  0
         CommonTree _first_0 = null;
 11643  0
         CommonTree _last = null;
 11644  
 
 11645  0
         CommonTree ASTERISK289=null;
 11646  0
         CommonTree QUESTION_MARK290=null;
 11647  0
         CommonTree PLUS291=null;
 11648  0
         CommonTree OPEN_CURLY_BRACE292=null;
 11649  0
         CommonTree INTEGER293=null;
 11650  0
         CommonTree COMMA294=null;
 11651  0
         CommonTree CLOSE_CURLY_BRACE295=null;
 11652  0
         CommonTree INTEGER296=null;
 11653  0
         CommonTree CLOSE_CURLY_BRACE297=null;
 11654  0
         CommonTree CLOSE_CURLY_BRACE298=null;
 11655  0
         CommonTree COMMA299=null;
 11656  0
         CommonTree INTEGER300=null;
 11657  0
         CommonTree CLOSE_CURLY_BRACE301=null;
 11658  
 
 11659  0
         CommonTree ASTERISK289_tree=null;
 11660  0
         CommonTree QUESTION_MARK290_tree=null;
 11661  0
         CommonTree PLUS291_tree=null;
 11662  0
         CommonTree OPEN_CURLY_BRACE292_tree=null;
 11663  0
         CommonTree INTEGER293_tree=null;
 11664  0
         CommonTree COMMA294_tree=null;
 11665  0
         CommonTree CLOSE_CURLY_BRACE295_tree=null;
 11666  0
         CommonTree INTEGER296_tree=null;
 11667  0
         CommonTree CLOSE_CURLY_BRACE297_tree=null;
 11668  0
         CommonTree CLOSE_CURLY_BRACE298_tree=null;
 11669  0
         CommonTree COMMA299_tree=null;
 11670  0
         CommonTree INTEGER300_tree=null;
 11671  0
         CommonTree CLOSE_CURLY_BRACE301_tree=null;
 11672  
 
 11673  
         try {
 11674  
             // com\\googlecode\\sparkleg\\SparqlT.g:365:5: ( ( ASTERISK | QUESTION_MARK | PLUS | OPEN_CURLY_BRACE ( INTEGER ( COMMA ( CLOSE_CURLY_BRACE | INTEGER CLOSE_CURLY_BRACE ) | CLOSE_CURLY_BRACE ) | COMMA INTEGER CLOSE_CURLY_BRACE ) ) )
 11675  
             // com\\googlecode\\sparkleg\\SparqlT.g:365:7: ( ASTERISK | QUESTION_MARK | PLUS | OPEN_CURLY_BRACE ( INTEGER ( COMMA ( CLOSE_CURLY_BRACE | INTEGER CLOSE_CURLY_BRACE ) | CLOSE_CURLY_BRACE ) | COMMA INTEGER CLOSE_CURLY_BRACE ) )
 11676  
             {
 11677  0
             root_0 = (CommonTree)adaptor.nil();
 11678  
 
 11679  
 
 11680  
             // com\\googlecode\\sparkleg\\SparqlT.g:365:7: ( ASTERISK | QUESTION_MARK | PLUS | OPEN_CURLY_BRACE ( INTEGER ( COMMA ( CLOSE_CURLY_BRACE | INTEGER CLOSE_CURLY_BRACE ) | CLOSE_CURLY_BRACE ) | COMMA INTEGER CLOSE_CURLY_BRACE ) )
 11681  0
             int alt115=4;
 11682  0
             switch ( input.LA(1) ) {
 11683  
             case ASTERISK:
 11684  
                 {
 11685  0
                 alt115=1;
 11686  
                 }
 11687  0
                 break;
 11688  
             case QUESTION_MARK:
 11689  
                 {
 11690  0
                 alt115=2;
 11691  
                 }
 11692  0
                 break;
 11693  
             case PLUS:
 11694  
                 {
 11695  0
                 alt115=3;
 11696  
                 }
 11697  0
                 break;
 11698  
             case OPEN_CURLY_BRACE:
 11699  
                 {
 11700  0
                 alt115=4;
 11701  
                 }
 11702  0
                 break;
 11703  
             default:
 11704  0
                 NoViableAltException nvae =
 11705  
                     new NoViableAltException("", 115, 0, input);
 11706  
 
 11707  0
                 throw nvae;
 11708  
 
 11709  
             }
 11710  
 
 11711  0
             switch (alt115) {
 11712  
                 case 1 :
 11713  
                     // com\\googlecode\\sparkleg\\SparqlT.g:365:8: ASTERISK
 11714  
                     {
 11715  0
                     _last = (CommonTree)input.LT(1);
 11716  0
                     ASTERISK289=(CommonTree)match(input,ASTERISK,FOLLOW_ASTERISK_in_pathMod2391); 
 11717  0
                     ASTERISK289_tree = (CommonTree)adaptor.dupNode(ASTERISK289);
 11718  
 
 11719  
 
 11720  0
                     adaptor.addChild(root_0, ASTERISK289_tree);
 11721  
 
 11722  
 
 11723  
                     }
 11724  0
                     break;
 11725  
                 case 2 :
 11726  
                     // com\\googlecode\\sparkleg\\SparqlT.g:365:19: QUESTION_MARK
 11727  
                     {
 11728  0
                     _last = (CommonTree)input.LT(1);
 11729  0
                     QUESTION_MARK290=(CommonTree)match(input,QUESTION_MARK,FOLLOW_QUESTION_MARK_in_pathMod2395); 
 11730  0
                     QUESTION_MARK290_tree = (CommonTree)adaptor.dupNode(QUESTION_MARK290);
 11731  
 
 11732  
 
 11733  0
                     adaptor.addChild(root_0, QUESTION_MARK290_tree);
 11734  
 
 11735  
 
 11736  
                     }
 11737  0
                     break;
 11738  
                 case 3 :
 11739  
                     // com\\googlecode\\sparkleg\\SparqlT.g:365:35: PLUS
 11740  
                     {
 11741  0
                     _last = (CommonTree)input.LT(1);
 11742  0
                     PLUS291=(CommonTree)match(input,PLUS,FOLLOW_PLUS_in_pathMod2399); 
 11743  0
                     PLUS291_tree = (CommonTree)adaptor.dupNode(PLUS291);
 11744  
 
 11745  
 
 11746  0
                     adaptor.addChild(root_0, PLUS291_tree);
 11747  
 
 11748  
 
 11749  
                     }
 11750  0
                     break;
 11751  
                 case 4 :
 11752  
                     // com\\googlecode\\sparkleg\\SparqlT.g:365:42: OPEN_CURLY_BRACE ( INTEGER ( COMMA ( CLOSE_CURLY_BRACE | INTEGER CLOSE_CURLY_BRACE ) | CLOSE_CURLY_BRACE ) | COMMA INTEGER CLOSE_CURLY_BRACE )
 11753  
                     {
 11754  0
                     _last = (CommonTree)input.LT(1);
 11755  0
                     OPEN_CURLY_BRACE292=(CommonTree)match(input,OPEN_CURLY_BRACE,FOLLOW_OPEN_CURLY_BRACE_in_pathMod2403); 
 11756  0
                     OPEN_CURLY_BRACE292_tree = (CommonTree)adaptor.dupNode(OPEN_CURLY_BRACE292);
 11757  
 
 11758  
 
 11759  0
                     adaptor.addChild(root_0, OPEN_CURLY_BRACE292_tree);
 11760  
 
 11761  
 
 11762  
                     // com\\googlecode\\sparkleg\\SparqlT.g:365:59: ( INTEGER ( COMMA ( CLOSE_CURLY_BRACE | INTEGER CLOSE_CURLY_BRACE ) | CLOSE_CURLY_BRACE ) | COMMA INTEGER CLOSE_CURLY_BRACE )
 11763  0
                     int alt114=2;
 11764  0
                     switch ( input.LA(1) ) {
 11765  
                     case INTEGER:
 11766  
                         {
 11767  0
                         alt114=1;
 11768  
                         }
 11769  0
                         break;
 11770  
                     case COMMA:
 11771  
                         {
 11772  0
                         alt114=2;
 11773  
                         }
 11774  0
                         break;
 11775  
                     default:
 11776  0
                         NoViableAltException nvae =
 11777  
                             new NoViableAltException("", 114, 0, input);
 11778  
 
 11779  0
                         throw nvae;
 11780  
 
 11781  
                     }
 11782  
 
 11783  0
                     switch (alt114) {
 11784  
                         case 1 :
 11785  
                             // com\\googlecode\\sparkleg\\SparqlT.g:365:60: INTEGER ( COMMA ( CLOSE_CURLY_BRACE | INTEGER CLOSE_CURLY_BRACE ) | CLOSE_CURLY_BRACE )
 11786  
                             {
 11787  0
                             _last = (CommonTree)input.LT(1);
 11788  0
                             INTEGER293=(CommonTree)match(input,INTEGER,FOLLOW_INTEGER_in_pathMod2406); 
 11789  0
                             INTEGER293_tree = (CommonTree)adaptor.dupNode(INTEGER293);
 11790  
 
 11791  
 
 11792  0
                             adaptor.addChild(root_0, INTEGER293_tree);
 11793  
 
 11794  
 
 11795  
                             // com\\googlecode\\sparkleg\\SparqlT.g:365:68: ( COMMA ( CLOSE_CURLY_BRACE | INTEGER CLOSE_CURLY_BRACE ) | CLOSE_CURLY_BRACE )
 11796  0
                             int alt113=2;
 11797  0
                             switch ( input.LA(1) ) {
 11798  
                             case COMMA:
 11799  
                                 {
 11800  0
                                 alt113=1;
 11801  
                                 }
 11802  0
                                 break;
 11803  
                             case CLOSE_CURLY_BRACE:
 11804  
                                 {
 11805  0
                                 alt113=2;
 11806  
                                 }
 11807  0
                                 break;
 11808  
                             default:
 11809  0
                                 NoViableAltException nvae =
 11810  
                                     new NoViableAltException("", 113, 0, input);
 11811  
 
 11812  0
                                 throw nvae;
 11813  
 
 11814  
                             }
 11815  
 
 11816  0
                             switch (alt113) {
 11817  
                                 case 1 :
 11818  
                                     // com\\googlecode\\sparkleg\\SparqlT.g:365:69: COMMA ( CLOSE_CURLY_BRACE | INTEGER CLOSE_CURLY_BRACE )
 11819  
                                     {
 11820  0
                                     _last = (CommonTree)input.LT(1);
 11821  0
                                     COMMA294=(CommonTree)match(input,COMMA,FOLLOW_COMMA_in_pathMod2409); 
 11822  0
                                     COMMA294_tree = (CommonTree)adaptor.dupNode(COMMA294);
 11823  
 
 11824  
 
 11825  0
                                     adaptor.addChild(root_0, COMMA294_tree);
 11826  
 
 11827  
 
 11828  
                                     // com\\googlecode\\sparkleg\\SparqlT.g:365:75: ( CLOSE_CURLY_BRACE | INTEGER CLOSE_CURLY_BRACE )
 11829  0
                                     int alt112=2;
 11830  0
                                     switch ( input.LA(1) ) {
 11831  
                                     case CLOSE_CURLY_BRACE:
 11832  
                                         {
 11833  0
                                         alt112=1;
 11834  
                                         }
 11835  0
                                         break;
 11836  
                                     case INTEGER:
 11837  
                                         {
 11838  0
                                         alt112=2;
 11839  
                                         }
 11840  0
                                         break;
 11841  
                                     default:
 11842  0
                                         NoViableAltException nvae =
 11843  
                                             new NoViableAltException("", 112, 0, input);
 11844  
 
 11845  0
                                         throw nvae;
 11846  
 
 11847  
                                     }
 11848  
 
 11849  0
                                     switch (alt112) {
 11850  
                                         case 1 :
 11851  
                                             // com\\googlecode\\sparkleg\\SparqlT.g:365:76: CLOSE_CURLY_BRACE
 11852  
                                             {
 11853  0
                                             _last = (CommonTree)input.LT(1);
 11854  0
                                             CLOSE_CURLY_BRACE295=(CommonTree)match(input,CLOSE_CURLY_BRACE,FOLLOW_CLOSE_CURLY_BRACE_in_pathMod2412); 
 11855  0
                                             CLOSE_CURLY_BRACE295_tree = (CommonTree)adaptor.dupNode(CLOSE_CURLY_BRACE295);
 11856  
 
 11857  
 
 11858  0
                                             adaptor.addChild(root_0, CLOSE_CURLY_BRACE295_tree);
 11859  
 
 11860  
 
 11861  
                                             }
 11862  0
                                             break;
 11863  
                                         case 2 :
 11864  
                                             // com\\googlecode\\sparkleg\\SparqlT.g:365:96: INTEGER CLOSE_CURLY_BRACE
 11865  
                                             {
 11866  0
                                             _last = (CommonTree)input.LT(1);
 11867  0
                                             INTEGER296=(CommonTree)match(input,INTEGER,FOLLOW_INTEGER_in_pathMod2416); 
 11868  0
                                             INTEGER296_tree = (CommonTree)adaptor.dupNode(INTEGER296);
 11869  
 
 11870  
 
 11871  0
                                             adaptor.addChild(root_0, INTEGER296_tree);
 11872  
 
 11873  
 
 11874  0
                                             _last = (CommonTree)input.LT(1);
 11875  0
                                             CLOSE_CURLY_BRACE297=(CommonTree)match(input,CLOSE_CURLY_BRACE,FOLLOW_CLOSE_CURLY_BRACE_in_pathMod2418); 
 11876  0
                                             CLOSE_CURLY_BRACE297_tree = (CommonTree)adaptor.dupNode(CLOSE_CURLY_BRACE297);
 11877  
 
 11878  
 
 11879  0
                                             adaptor.addChild(root_0, CLOSE_CURLY_BRACE297_tree);
 11880  
 
 11881  
 
 11882  
                                             }
 11883  
                                             break;
 11884  
 
 11885  
                                     }
 11886  
 
 11887  
 
 11888  
                                     }
 11889  0
                                     break;
 11890  
                                 case 2 :
 11891  
                                     // com\\googlecode\\sparkleg\\SparqlT.g:365:125: CLOSE_CURLY_BRACE
 11892  
                                     {
 11893  0
                                     _last = (CommonTree)input.LT(1);
 11894  0
                                     CLOSE_CURLY_BRACE298=(CommonTree)match(input,CLOSE_CURLY_BRACE,FOLLOW_CLOSE_CURLY_BRACE_in_pathMod2423); 
 11895  0
                                     CLOSE_CURLY_BRACE298_tree = (CommonTree)adaptor.dupNode(CLOSE_CURLY_BRACE298);
 11896  
 
 11897  
 
 11898  0
                                     adaptor.addChild(root_0, CLOSE_CURLY_BRACE298_tree);
 11899  
 
 11900  
 
 11901  
                                     }
 11902  
                                     break;
 11903  
 
 11904  
                             }
 11905  
 
 11906  
 
 11907  
                             }
 11908  0
                             break;
 11909  
                         case 2 :
 11910  
                             // com\\googlecode\\sparkleg\\SparqlT.g:365:146: COMMA INTEGER CLOSE_CURLY_BRACE
 11911  
                             {
 11912  0
                             _last = (CommonTree)input.LT(1);
 11913  0
                             COMMA299=(CommonTree)match(input,COMMA,FOLLOW_COMMA_in_pathMod2428); 
 11914  0
                             COMMA299_tree = (CommonTree)adaptor.dupNode(COMMA299);
 11915  
 
 11916  
 
 11917  0
                             adaptor.addChild(root_0, COMMA299_tree);
 11918  
 
 11919  
 
 11920  0
                             _last = (CommonTree)input.LT(1);
 11921  0
                             INTEGER300=(CommonTree)match(input,INTEGER,FOLLOW_INTEGER_in_pathMod2430); 
 11922  0
                             INTEGER300_tree = (CommonTree)adaptor.dupNode(INTEGER300);
 11923  
 
 11924  
 
 11925  0
                             adaptor.addChild(root_0, INTEGER300_tree);
 11926  
 
 11927  
 
 11928  0
                             _last = (CommonTree)input.LT(1);
 11929  0
                             CLOSE_CURLY_BRACE301=(CommonTree)match(input,CLOSE_CURLY_BRACE,FOLLOW_CLOSE_CURLY_BRACE_in_pathMod2432); 
 11930  0
                             CLOSE_CURLY_BRACE301_tree = (CommonTree)adaptor.dupNode(CLOSE_CURLY_BRACE301);
 11931  
 
 11932  
 
 11933  0
                             adaptor.addChild(root_0, CLOSE_CURLY_BRACE301_tree);
 11934  
 
 11935  
 
 11936  
                             }
 11937  
                             break;
 11938  
 
 11939  
                     }
 11940  
 
 11941  
 
 11942  
                     }
 11943  
                     break;
 11944  
 
 11945  
             }
 11946  
 
 11947  
 
 11948  
             }
 11949  
 
 11950  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 11951  
 
 11952  
         }
 11953  0
         catch (RecognitionException re) {
 11954  0
             reportError(re);
 11955  0
             recover(input,re);
 11956  
         }
 11957  
 
 11958  0
         finally {
 11959  
                 // do for sure before leaving
 11960  0
         }
 11961  0
         return retval;
 11962  
     }
 11963  
     // $ANTLR end "pathMod"
 11964  
 
 11965  
 
 11966  0
     public static class pathPrimary_return extends TreeRuleReturnScope {
 11967  
         CommonTree tree;
 11968  0
         public Object getTree() { return tree; }
 11969  
     };
 11970  
 
 11971  
 
 11972  
     // $ANTLR start "pathPrimary"
 11973  
     // com\\googlecode\\sparkleg\\SparqlT.g:368:1: pathPrimary : ( ^( PATH_PRIMARY iriRef ) | ^( PATH_PRIMARY A ) | ^( PATH_PRIMARY NEGATION pathNegatedPropertySet ) | ^( PATH_PRIMARY path ) );
 11974  
     public final SparqlT.pathPrimary_return pathPrimary() throws RecognitionException {
 11975  0
         SparqlT.pathPrimary_return retval = new SparqlT.pathPrimary_return();
 11976  0
         retval.start = input.LT(1);
 11977  
 
 11978  
 
 11979  0
         CommonTree root_0 = null;
 11980  
 
 11981  0
         CommonTree _first_0 = null;
 11982  0
         CommonTree _last = null;
 11983  
 
 11984  0
         CommonTree PATH_PRIMARY302=null;
 11985  0
         CommonTree PATH_PRIMARY304=null;
 11986  0
         CommonTree A305=null;
 11987  0
         CommonTree PATH_PRIMARY306=null;
 11988  0
         CommonTree NEGATION307=null;
 11989  0
         CommonTree PATH_PRIMARY309=null;
 11990  0
         SparqlT.iriRef_return iriRef303 =null;
 11991  
 
 11992  0
         SparqlT.pathNegatedPropertySet_return pathNegatedPropertySet308 =null;
 11993  
 
 11994  0
         SparqlT.path_return path310 =null;
 11995  
 
 11996  
 
 11997  0
         CommonTree PATH_PRIMARY302_tree=null;
 11998  0
         CommonTree PATH_PRIMARY304_tree=null;
 11999  0
         CommonTree A305_tree=null;
 12000  0
         CommonTree PATH_PRIMARY306_tree=null;
 12001  0
         CommonTree NEGATION307_tree=null;
 12002  0
         CommonTree PATH_PRIMARY309_tree=null;
 12003  
 
 12004  
         try {
 12005  
             // com\\googlecode\\sparkleg\\SparqlT.g:369:5: ( ^( PATH_PRIMARY iriRef ) | ^( PATH_PRIMARY A ) | ^( PATH_PRIMARY NEGATION pathNegatedPropertySet ) | ^( PATH_PRIMARY path ) )
 12006  0
             int alt116=4;
 12007  0
             switch ( input.LA(1) ) {
 12008  
             case PATH_PRIMARY:
 12009  
                 {
 12010  0
                 switch ( input.LA(2) ) {
 12011  
                 case DOWN:
 12012  
                     {
 12013  0
                     switch ( input.LA(3) ) {
 12014  
                     case A:
 12015  
                         {
 12016  0
                         alt116=2;
 12017  
                         }
 12018  0
                         break;
 12019  
                     case NEGATION:
 12020  
                         {
 12021  0
                         alt116=3;
 12022  
                         }
 12023  0
                         break;
 12024  
                     case IRI_REF:
 12025  
                     case PNAME_LN:
 12026  
                     case PNAME_NS:
 12027  
                         {
 12028  0
                         alt116=1;
 12029  
                         }
 12030  0
                         break;
 12031  
                     case PATH:
 12032  
                         {
 12033  0
                         alt116=4;
 12034  
                         }
 12035  0
                         break;
 12036  
                     default:
 12037  0
                         NoViableAltException nvae =
 12038  
                             new NoViableAltException("", 116, 2, input);
 12039  
 
 12040  0
                         throw nvae;
 12041  
 
 12042  
                     }
 12043  
 
 12044  
                     }
 12045  0
                     break;
 12046  
                 default:
 12047  0
                     NoViableAltException nvae =
 12048  
                         new NoViableAltException("", 116, 1, input);
 12049  
 
 12050  0
                     throw nvae;
 12051  
 
 12052  
                 }
 12053  
 
 12054  
                 }
 12055  0
                 break;
 12056  
             default:
 12057  0
                 NoViableAltException nvae =
 12058  
                     new NoViableAltException("", 116, 0, input);
 12059  
 
 12060  0
                 throw nvae;
 12061  
 
 12062  
             }
 12063  
 
 12064  0
             switch (alt116) {
 12065  
                 case 1 :
 12066  
                     // com\\googlecode\\sparkleg\\SparqlT.g:369:7: ^( PATH_PRIMARY iriRef )
 12067  
                     {
 12068  0
                     root_0 = (CommonTree)adaptor.nil();
 12069  
 
 12070  
 
 12071  0
                     _last = (CommonTree)input.LT(1);
 12072  
                     {
 12073  0
                     CommonTree _save_last_1 = _last;
 12074  0
                     CommonTree _first_1 = null;
 12075  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 12076  0
                     _last = (CommonTree)input.LT(1);
 12077  0
                     PATH_PRIMARY302=(CommonTree)match(input,PATH_PRIMARY,FOLLOW_PATH_PRIMARY_in_pathPrimary2452); 
 12078  0
                     PATH_PRIMARY302_tree = (CommonTree)adaptor.dupNode(PATH_PRIMARY302);
 12079  
 
 12080  
 
 12081  0
                     root_1 = (CommonTree)adaptor.becomeRoot(PATH_PRIMARY302_tree, root_1);
 12082  
 
 12083  
 
 12084  0
                     match(input, Token.DOWN, null); 
 12085  0
                     _last = (CommonTree)input.LT(1);
 12086  0
                     pushFollow(FOLLOW_iriRef_in_pathPrimary2454);
 12087  0
                     iriRef303=iriRef();
 12088  
 
 12089  0
                     state._fsp--;
 12090  
 
 12091  0
                     adaptor.addChild(root_1, iriRef303.getTree());
 12092  
 
 12093  
 
 12094  0
                     match(input, Token.UP, null); 
 12095  0
                     adaptor.addChild(root_0, root_1);
 12096  0
                     _last = _save_last_1;
 12097  
                     }
 12098  
 
 12099  
 
 12100  
                     }
 12101  0
                     break;
 12102  
                 case 2 :
 12103  
                     // com\\googlecode\\sparkleg\\SparqlT.g:370:7: ^( PATH_PRIMARY A )
 12104  
                     {
 12105  0
                     root_0 = (CommonTree)adaptor.nil();
 12106  
 
 12107  
 
 12108  0
                     _last = (CommonTree)input.LT(1);
 12109  
                     {
 12110  0
                     CommonTree _save_last_1 = _last;
 12111  0
                     CommonTree _first_1 = null;
 12112  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 12113  0
                     _last = (CommonTree)input.LT(1);
 12114  0
                     PATH_PRIMARY304=(CommonTree)match(input,PATH_PRIMARY,FOLLOW_PATH_PRIMARY_in_pathPrimary2464); 
 12115  0
                     PATH_PRIMARY304_tree = (CommonTree)adaptor.dupNode(PATH_PRIMARY304);
 12116  
 
 12117  
 
 12118  0
                     root_1 = (CommonTree)adaptor.becomeRoot(PATH_PRIMARY304_tree, root_1);
 12119  
 
 12120  
 
 12121  0
                     match(input, Token.DOWN, null); 
 12122  0
                     _last = (CommonTree)input.LT(1);
 12123  0
                     A305=(CommonTree)match(input,A,FOLLOW_A_in_pathPrimary2466); 
 12124  0
                     A305_tree = (CommonTree)adaptor.dupNode(A305);
 12125  
 
 12126  
 
 12127  0
                     adaptor.addChild(root_1, A305_tree);
 12128  
 
 12129  
 
 12130  0
                     match(input, Token.UP, null); 
 12131  0
                     adaptor.addChild(root_0, root_1);
 12132  0
                     _last = _save_last_1;
 12133  
                     }
 12134  
 
 12135  
 
 12136  
                     }
 12137  0
                     break;
 12138  
                 case 3 :
 12139  
                     // com\\googlecode\\sparkleg\\SparqlT.g:371:7: ^( PATH_PRIMARY NEGATION pathNegatedPropertySet )
 12140  
                     {
 12141  0
                     root_0 = (CommonTree)adaptor.nil();
 12142  
 
 12143  
 
 12144  0
                     _last = (CommonTree)input.LT(1);
 12145  
                     {
 12146  0
                     CommonTree _save_last_1 = _last;
 12147  0
                     CommonTree _first_1 = null;
 12148  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 12149  0
                     _last = (CommonTree)input.LT(1);
 12150  0
                     PATH_PRIMARY306=(CommonTree)match(input,PATH_PRIMARY,FOLLOW_PATH_PRIMARY_in_pathPrimary2476); 
 12151  0
                     PATH_PRIMARY306_tree = (CommonTree)adaptor.dupNode(PATH_PRIMARY306);
 12152  
 
 12153  
 
 12154  0
                     root_1 = (CommonTree)adaptor.becomeRoot(PATH_PRIMARY306_tree, root_1);
 12155  
 
 12156  
 
 12157  0
                     match(input, Token.DOWN, null); 
 12158  0
                     _last = (CommonTree)input.LT(1);
 12159  0
                     NEGATION307=(CommonTree)match(input,NEGATION,FOLLOW_NEGATION_in_pathPrimary2478); 
 12160  0
                     NEGATION307_tree = (CommonTree)adaptor.dupNode(NEGATION307);
 12161  
 
 12162  
 
 12163  0
                     adaptor.addChild(root_1, NEGATION307_tree);
 12164  
 
 12165  
 
 12166  0
                     _last = (CommonTree)input.LT(1);
 12167  0
                     pushFollow(FOLLOW_pathNegatedPropertySet_in_pathPrimary2480);
 12168  0
                     pathNegatedPropertySet308=pathNegatedPropertySet();
 12169  
 
 12170  0
                     state._fsp--;
 12171  
 
 12172  0
                     adaptor.addChild(root_1, pathNegatedPropertySet308.getTree());
 12173  
 
 12174  
 
 12175  0
                     match(input, Token.UP, null); 
 12176  0
                     adaptor.addChild(root_0, root_1);
 12177  0
                     _last = _save_last_1;
 12178  
                     }
 12179  
 
 12180  
 
 12181  
                     }
 12182  0
                     break;
 12183  
                 case 4 :
 12184  
                     // com\\googlecode\\sparkleg\\SparqlT.g:372:7: ^( PATH_PRIMARY path )
 12185  
                     {
 12186  0
                     root_0 = (CommonTree)adaptor.nil();
 12187  
 
 12188  
 
 12189  0
                     _last = (CommonTree)input.LT(1);
 12190  
                     {
 12191  0
                     CommonTree _save_last_1 = _last;
 12192  0
                     CommonTree _first_1 = null;
 12193  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 12194  0
                     _last = (CommonTree)input.LT(1);
 12195  0
                     PATH_PRIMARY309=(CommonTree)match(input,PATH_PRIMARY,FOLLOW_PATH_PRIMARY_in_pathPrimary2490); 
 12196  0
                     PATH_PRIMARY309_tree = (CommonTree)adaptor.dupNode(PATH_PRIMARY309);
 12197  
 
 12198  
 
 12199  0
                     root_1 = (CommonTree)adaptor.becomeRoot(PATH_PRIMARY309_tree, root_1);
 12200  
 
 12201  
 
 12202  0
                     match(input, Token.DOWN, null); 
 12203  0
                     _last = (CommonTree)input.LT(1);
 12204  0
                     pushFollow(FOLLOW_path_in_pathPrimary2492);
 12205  0
                     path310=path();
 12206  
 
 12207  0
                     state._fsp--;
 12208  
 
 12209  0
                     adaptor.addChild(root_1, path310.getTree());
 12210  
 
 12211  
 
 12212  0
                     match(input, Token.UP, null); 
 12213  0
                     adaptor.addChild(root_0, root_1);
 12214  0
                     _last = _save_last_1;
 12215  
                     }
 12216  
 
 12217  
 
 12218  
                     }
 12219  
                     break;
 12220  
 
 12221  
             }
 12222  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 12223  
 
 12224  
         }
 12225  0
         catch (RecognitionException re) {
 12226  0
             reportError(re);
 12227  0
             recover(input,re);
 12228  
         }
 12229  
 
 12230  0
         finally {
 12231  
                 // do for sure before leaving
 12232  0
         }
 12233  0
         return retval;
 12234  
     }
 12235  
     // $ANTLR end "pathPrimary"
 12236  
 
 12237  
 
 12238  0
     public static class pathNegatedPropertySet_return extends TreeRuleReturnScope {
 12239  
         CommonTree tree;
 12240  0
         public Object getTree() { return tree; }
 12241  
     };
 12242  
 
 12243  
 
 12244  
     // $ANTLR start "pathNegatedPropertySet"
 12245  
     // com\\googlecode\\sparkleg\\SparqlT.g:375:1: pathNegatedPropertySet : ^( PATH_NEGATED ( pathOneInPropertySet )+ ) ;
 12246  
     public final SparqlT.pathNegatedPropertySet_return pathNegatedPropertySet() throws RecognitionException {
 12247  0
         SparqlT.pathNegatedPropertySet_return retval = new SparqlT.pathNegatedPropertySet_return();
 12248  0
         retval.start = input.LT(1);
 12249  
 
 12250  
 
 12251  0
         CommonTree root_0 = null;
 12252  
 
 12253  0
         CommonTree _first_0 = null;
 12254  0
         CommonTree _last = null;
 12255  
 
 12256  0
         CommonTree PATH_NEGATED311=null;
 12257  0
         SparqlT.pathOneInPropertySet_return pathOneInPropertySet312 =null;
 12258  
 
 12259  
 
 12260  0
         CommonTree PATH_NEGATED311_tree=null;
 12261  
 
 12262  
         try {
 12263  
             // com\\googlecode\\sparkleg\\SparqlT.g:376:5: ( ^( PATH_NEGATED ( pathOneInPropertySet )+ ) )
 12264  
             // com\\googlecode\\sparkleg\\SparqlT.g:376:7: ^( PATH_NEGATED ( pathOneInPropertySet )+ )
 12265  
             {
 12266  0
             root_0 = (CommonTree)adaptor.nil();
 12267  
 
 12268  
 
 12269  0
             _last = (CommonTree)input.LT(1);
 12270  
             {
 12271  0
             CommonTree _save_last_1 = _last;
 12272  0
             CommonTree _first_1 = null;
 12273  0
             CommonTree root_1 = (CommonTree)adaptor.nil();
 12274  0
             _last = (CommonTree)input.LT(1);
 12275  0
             PATH_NEGATED311=(CommonTree)match(input,PATH_NEGATED,FOLLOW_PATH_NEGATED_in_pathNegatedPropertySet2511); 
 12276  0
             PATH_NEGATED311_tree = (CommonTree)adaptor.dupNode(PATH_NEGATED311);
 12277  
 
 12278  
 
 12279  0
             root_1 = (CommonTree)adaptor.becomeRoot(PATH_NEGATED311_tree, root_1);
 12280  
 
 12281  
 
 12282  0
             match(input, Token.DOWN, null); 
 12283  
             // com\\googlecode\\sparkleg\\SparqlT.g:376:22: ( pathOneInPropertySet )+
 12284  0
             int cnt117=0;
 12285  
             loop117:
 12286  
             do {
 12287  0
                 int alt117=2;
 12288  0
                 switch ( input.LA(1) ) {
 12289  
                 case A:
 12290  
                 case INVERSE:
 12291  
                 case IRI_REF:
 12292  
                 case PNAME_LN:
 12293  
                 case PNAME_NS:
 12294  
                     {
 12295  0
                     alt117=1;
 12296  
                     }
 12297  
                     break;
 12298  
 
 12299  
                 }
 12300  
 
 12301  0
                 switch (alt117) {
 12302  
                     case 1 :
 12303  
                         // com\\googlecode\\sparkleg\\SparqlT.g:376:22: pathOneInPropertySet
 12304  
                         {
 12305  0
                         _last = (CommonTree)input.LT(1);
 12306  0
                         pushFollow(FOLLOW_pathOneInPropertySet_in_pathNegatedPropertySet2513);
 12307  0
                         pathOneInPropertySet312=pathOneInPropertySet();
 12308  
 
 12309  0
                         state._fsp--;
 12310  
 
 12311  0
                         adaptor.addChild(root_1, pathOneInPropertySet312.getTree());
 12312  
 
 12313  
 
 12314  
                         }
 12315  0
                         break;
 12316  
 
 12317  
                     default :
 12318  0
                         if ( cnt117 >= 1 ) break loop117;
 12319  0
                         EarlyExitException eee =
 12320  
                             new EarlyExitException(117, input);
 12321  0
                         throw eee;
 12322  
                 }
 12323  0
                 cnt117++;
 12324  0
             } while (true);
 12325  
 
 12326  
 
 12327  0
             match(input, Token.UP, null); 
 12328  0
             adaptor.addChild(root_0, root_1);
 12329  0
             _last = _save_last_1;
 12330  
             }
 12331  
 
 12332  
 
 12333  
             }
 12334  
 
 12335  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 12336  
 
 12337  
         }
 12338  0
         catch (RecognitionException re) {
 12339  0
             reportError(re);
 12340  0
             recover(input,re);
 12341  
         }
 12342  
 
 12343  0
         finally {
 12344  
                 // do for sure before leaving
 12345  0
         }
 12346  0
         return retval;
 12347  
     }
 12348  
     // $ANTLR end "pathNegatedPropertySet"
 12349  
 
 12350  
 
 12351  0
     public static class pathOneInPropertySet_return extends TreeRuleReturnScope {
 12352  
         CommonTree tree;
 12353  0
         public Object getTree() { return tree; }
 12354  
     };
 12355  
 
 12356  
 
 12357  
     // $ANTLR start "pathOneInPropertySet"
 12358  
     // com\\googlecode\\sparkleg\\SparqlT.g:379:1: pathOneInPropertySet : ( INVERSE )? ( iriRef | A ) ;
 12359  
     public final SparqlT.pathOneInPropertySet_return pathOneInPropertySet() throws RecognitionException {
 12360  0
         SparqlT.pathOneInPropertySet_return retval = new SparqlT.pathOneInPropertySet_return();
 12361  0
         retval.start = input.LT(1);
 12362  
 
 12363  
 
 12364  0
         CommonTree root_0 = null;
 12365  
 
 12366  0
         CommonTree _first_0 = null;
 12367  0
         CommonTree _last = null;
 12368  
 
 12369  0
         CommonTree INVERSE313=null;
 12370  0
         CommonTree A315=null;
 12371  0
         SparqlT.iriRef_return iriRef314 =null;
 12372  
 
 12373  
 
 12374  0
         CommonTree INVERSE313_tree=null;
 12375  0
         CommonTree A315_tree=null;
 12376  
 
 12377  
         try {
 12378  
             // com\\googlecode\\sparkleg\\SparqlT.g:380:5: ( ( INVERSE )? ( iriRef | A ) )
 12379  
             // com\\googlecode\\sparkleg\\SparqlT.g:380:7: ( INVERSE )? ( iriRef | A )
 12380  
             {
 12381  0
             root_0 = (CommonTree)adaptor.nil();
 12382  
 
 12383  
 
 12384  
             // com\\googlecode\\sparkleg\\SparqlT.g:380:7: ( INVERSE )?
 12385  0
             int alt118=2;
 12386  0
             switch ( input.LA(1) ) {
 12387  
                 case INVERSE:
 12388  
                     {
 12389  0
                     alt118=1;
 12390  
                     }
 12391  
                     break;
 12392  
             }
 12393  
 
 12394  0
             switch (alt118) {
 12395  
                 case 1 :
 12396  
                     // com\\googlecode\\sparkleg\\SparqlT.g:380:7: INVERSE
 12397  
                     {
 12398  0
                     _last = (CommonTree)input.LT(1);
 12399  0
                     INVERSE313=(CommonTree)match(input,INVERSE,FOLLOW_INVERSE_in_pathOneInPropertySet2535); 
 12400  0
                     INVERSE313_tree = (CommonTree)adaptor.dupNode(INVERSE313);
 12401  
 
 12402  
 
 12403  0
                     adaptor.addChild(root_0, INVERSE313_tree);
 12404  
 
 12405  
 
 12406  
                     }
 12407  
                     break;
 12408  
 
 12409  
             }
 12410  
 
 12411  
 
 12412  
             // com\\googlecode\\sparkleg\\SparqlT.g:380:16: ( iriRef | A )
 12413  0
             int alt119=2;
 12414  0
             switch ( input.LA(1) ) {
 12415  
             case IRI_REF:
 12416  
             case PNAME_LN:
 12417  
             case PNAME_NS:
 12418  
                 {
 12419  0
                 alt119=1;
 12420  
                 }
 12421  0
                 break;
 12422  
             case A:
 12423  
                 {
 12424  0
                 alt119=2;
 12425  
                 }
 12426  0
                 break;
 12427  
             default:
 12428  0
                 NoViableAltException nvae =
 12429  
                     new NoViableAltException("", 119, 0, input);
 12430  
 
 12431  0
                 throw nvae;
 12432  
 
 12433  
             }
 12434  
 
 12435  0
             switch (alt119) {
 12436  
                 case 1 :
 12437  
                     // com\\googlecode\\sparkleg\\SparqlT.g:380:17: iriRef
 12438  
                     {
 12439  0
                     _last = (CommonTree)input.LT(1);
 12440  0
                     pushFollow(FOLLOW_iriRef_in_pathOneInPropertySet2539);
 12441  0
                     iriRef314=iriRef();
 12442  
 
 12443  0
                     state._fsp--;
 12444  
 
 12445  0
                     adaptor.addChild(root_0, iriRef314.getTree());
 12446  
 
 12447  
 
 12448  
                     }
 12449  0
                     break;
 12450  
                 case 2 :
 12451  
                     // com\\googlecode\\sparkleg\\SparqlT.g:380:26: A
 12452  
                     {
 12453  0
                     _last = (CommonTree)input.LT(1);
 12454  0
                     A315=(CommonTree)match(input,A,FOLLOW_A_in_pathOneInPropertySet2543); 
 12455  0
                     A315_tree = (CommonTree)adaptor.dupNode(A315);
 12456  
 
 12457  
 
 12458  0
                     adaptor.addChild(root_0, A315_tree);
 12459  
 
 12460  
 
 12461  
                     }
 12462  
                     break;
 12463  
 
 12464  
             }
 12465  
 
 12466  
 
 12467  
             }
 12468  
 
 12469  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 12470  
 
 12471  
         }
 12472  0
         catch (RecognitionException re) {
 12473  0
             reportError(re);
 12474  0
             recover(input,re);
 12475  
         }
 12476  
 
 12477  0
         finally {
 12478  
                 // do for sure before leaving
 12479  0
         }
 12480  0
         return retval;
 12481  
     }
 12482  
     // $ANTLR end "pathOneInPropertySet"
 12483  
 
 12484  
 
 12485  0
     public static class triplesNode_return extends TreeRuleReturnScope {
 12486  
         CommonTree tree;
 12487  0
         public Object getTree() { return tree; }
 12488  
     };
 12489  
 
 12490  
 
 12491  
     // $ANTLR start "triplesNode"
 12492  
     // com\\googlecode\\sparkleg\\SparqlT.g:383:1: triplesNode : ( ^( COLLECTION ( graphNode )+ ) | ^( TRIPLES_NODE propertyListNotEmpty ) );
 12493  
     public final SparqlT.triplesNode_return triplesNode() throws RecognitionException {
 12494  0
         SparqlT.triplesNode_return retval = new SparqlT.triplesNode_return();
 12495  0
         retval.start = input.LT(1);
 12496  
 
 12497  
 
 12498  0
         CommonTree root_0 = null;
 12499  
 
 12500  0
         CommonTree _first_0 = null;
 12501  0
         CommonTree _last = null;
 12502  
 
 12503  0
         CommonTree COLLECTION316=null;
 12504  0
         CommonTree TRIPLES_NODE318=null;
 12505  0
         SparqlT.graphNode_return graphNode317 =null;
 12506  
 
 12507  0
         SparqlT.propertyListNotEmpty_return propertyListNotEmpty319 =null;
 12508  
 
 12509  
 
 12510  0
         CommonTree COLLECTION316_tree=null;
 12511  0
         CommonTree TRIPLES_NODE318_tree=null;
 12512  
 
 12513  
         try {
 12514  
             // com\\googlecode\\sparkleg\\SparqlT.g:384:5: ( ^( COLLECTION ( graphNode )+ ) | ^( TRIPLES_NODE propertyListNotEmpty ) )
 12515  0
             int alt121=2;
 12516  0
             switch ( input.LA(1) ) {
 12517  
             case COLLECTION:
 12518  
                 {
 12519  0
                 alt121=1;
 12520  
                 }
 12521  0
                 break;
 12522  
             case TRIPLES_NODE:
 12523  
                 {
 12524  0
                 alt121=2;
 12525  
                 }
 12526  0
                 break;
 12527  
             default:
 12528  0
                 NoViableAltException nvae =
 12529  
                     new NoViableAltException("", 121, 0, input);
 12530  
 
 12531  0
                 throw nvae;
 12532  
 
 12533  
             }
 12534  
 
 12535  0
             switch (alt121) {
 12536  
                 case 1 :
 12537  
                     // com\\googlecode\\sparkleg\\SparqlT.g:384:7: ^( COLLECTION ( graphNode )+ )
 12538  
                     {
 12539  0
                     root_0 = (CommonTree)adaptor.nil();
 12540  
 
 12541  
 
 12542  0
                     _last = (CommonTree)input.LT(1);
 12543  
                     {
 12544  0
                     CommonTree _save_last_1 = _last;
 12545  0
                     CommonTree _first_1 = null;
 12546  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 12547  0
                     _last = (CommonTree)input.LT(1);
 12548  0
                     COLLECTION316=(CommonTree)match(input,COLLECTION,FOLLOW_COLLECTION_in_triplesNode2563); 
 12549  0
                     COLLECTION316_tree = (CommonTree)adaptor.dupNode(COLLECTION316);
 12550  
 
 12551  
 
 12552  0
                     root_1 = (CommonTree)adaptor.becomeRoot(COLLECTION316_tree, root_1);
 12553  
 
 12554  
 
 12555  0
                     match(input, Token.DOWN, null); 
 12556  
                     // com\\googlecode\\sparkleg\\SparqlT.g:384:20: ( graphNode )+
 12557  0
                     int cnt120=0;
 12558  
                     loop120:
 12559  
                     do {
 12560  0
                         int alt120=2;
 12561  0
                         switch ( input.LA(1) ) {
 12562  
                         case BLANK_NODE:
 12563  
                         case BLANK_NODE_LABEL:
 12564  
                         case COLLECTION:
 12565  
                         case DECIMAL:
 12566  
                         case DECIMAL_NEGATIVE:
 12567  
                         case DECIMAL_POSITIVE:
 12568  
                         case DOUBLE:
 12569  
                         case DOUBLE_NEGATIVE:
 12570  
                         case DOUBLE_POSITIVE:
 12571  
                         case FALSE:
 12572  
                         case INTEGER:
 12573  
                         case INTEGER_NEGATIVE:
 12574  
                         case INTEGER_POSITIVE:
 12575  
                         case IRI_REF:
 12576  
                         case OPEN_BRACE:
 12577  
                         case OPEN_SQUARE_BRACKET:
 12578  
                         case PNAME_LN:
 12579  
                         case PNAME_NS:
 12580  
                         case STRING_LITERAL1:
 12581  
                         case STRING_LITERAL2:
 12582  
                         case STRING_LITERAL_LONG1:
 12583  
                         case STRING_LITERAL_LONG2:
 12584  
                         case TRIPLES_NODE:
 12585  
                         case TRUE:
 12586  
                         case VAR1:
 12587  
                         case VAR2:
 12588  
                             {
 12589  0
                             alt120=1;
 12590  
                             }
 12591  
                             break;
 12592  
 
 12593  
                         }
 12594  
 
 12595  0
                         switch (alt120) {
 12596  
                             case 1 :
 12597  
                                 // com\\googlecode\\sparkleg\\SparqlT.g:384:20: graphNode
 12598  
                                 {
 12599  0
                                 _last = (CommonTree)input.LT(1);
 12600  0
                                 pushFollow(FOLLOW_graphNode_in_triplesNode2565);
 12601  0
                                 graphNode317=graphNode();
 12602  
 
 12603  0
                                 state._fsp--;
 12604  
 
 12605  0
                                 adaptor.addChild(root_1, graphNode317.getTree());
 12606  
 
 12607  
 
 12608  
                                 }
 12609  0
                                 break;
 12610  
 
 12611  
                             default :
 12612  0
                                 if ( cnt120 >= 1 ) break loop120;
 12613  0
                                 EarlyExitException eee =
 12614  
                                     new EarlyExitException(120, input);
 12615  0
                                 throw eee;
 12616  
                         }
 12617  0
                         cnt120++;
 12618  0
                     } while (true);
 12619  
 
 12620  
 
 12621  0
                     match(input, Token.UP, null); 
 12622  0
                     adaptor.addChild(root_0, root_1);
 12623  0
                     _last = _save_last_1;
 12624  
                     }
 12625  
 
 12626  
 
 12627  
                     }
 12628  0
                     break;
 12629  
                 case 2 :
 12630  
                     // com\\googlecode\\sparkleg\\SparqlT.g:385:7: ^( TRIPLES_NODE propertyListNotEmpty )
 12631  
                     {
 12632  0
                     root_0 = (CommonTree)adaptor.nil();
 12633  
 
 12634  
 
 12635  0
                     _last = (CommonTree)input.LT(1);
 12636  
                     {
 12637  0
                     CommonTree _save_last_1 = _last;
 12638  0
                     CommonTree _first_1 = null;
 12639  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 12640  0
                     _last = (CommonTree)input.LT(1);
 12641  0
                     TRIPLES_NODE318=(CommonTree)match(input,TRIPLES_NODE,FOLLOW_TRIPLES_NODE_in_triplesNode2576); 
 12642  0
                     TRIPLES_NODE318_tree = (CommonTree)adaptor.dupNode(TRIPLES_NODE318);
 12643  
 
 12644  
 
 12645  0
                     root_1 = (CommonTree)adaptor.becomeRoot(TRIPLES_NODE318_tree, root_1);
 12646  
 
 12647  
 
 12648  0
                     match(input, Token.DOWN, null); 
 12649  0
                     _last = (CommonTree)input.LT(1);
 12650  0
                     pushFollow(FOLLOW_propertyListNotEmpty_in_triplesNode2578);
 12651  0
                     propertyListNotEmpty319=propertyListNotEmpty();
 12652  
 
 12653  0
                     state._fsp--;
 12654  
 
 12655  0
                     adaptor.addChild(root_1, propertyListNotEmpty319.getTree());
 12656  
 
 12657  
 
 12658  0
                     match(input, Token.UP, null); 
 12659  0
                     adaptor.addChild(root_0, root_1);
 12660  0
                     _last = _save_last_1;
 12661  
                     }
 12662  
 
 12663  
 
 12664  
                     }
 12665  
                     break;
 12666  
 
 12667  
             }
 12668  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 12669  
 
 12670  
         }
 12671  0
         catch (RecognitionException re) {
 12672  0
             reportError(re);
 12673  0
             recover(input,re);
 12674  
         }
 12675  
 
 12676  0
         finally {
 12677  
                 // do for sure before leaving
 12678  0
         }
 12679  0
         return retval;
 12680  
     }
 12681  
     // $ANTLR end "triplesNode"
 12682  
 
 12683  
 
 12684  0
     public static class graphNode_return extends TreeRuleReturnScope {
 12685  
         CommonTree tree;
 12686  0
         public Object getTree() { return tree; }
 12687  
     };
 12688  
 
 12689  
 
 12690  
     // $ANTLR start "graphNode"
 12691  
     // com\\googlecode\\sparkleg\\SparqlT.g:388:1: graphNode : ( varOrTerm | triplesNode );
 12692  
     public final SparqlT.graphNode_return graphNode() throws RecognitionException {
 12693  0
         SparqlT.graphNode_return retval = new SparqlT.graphNode_return();
 12694  0
         retval.start = input.LT(1);
 12695  
 
 12696  
 
 12697  0
         CommonTree root_0 = null;
 12698  
 
 12699  0
         CommonTree _first_0 = null;
 12700  0
         CommonTree _last = null;
 12701  
 
 12702  0
         SparqlT.varOrTerm_return varOrTerm320 =null;
 12703  
 
 12704  0
         SparqlT.triplesNode_return triplesNode321 =null;
 12705  
 
 12706  
 
 12707  
 
 12708  
         try {
 12709  
             // com\\googlecode\\sparkleg\\SparqlT.g:389:5: ( varOrTerm | triplesNode )
 12710  0
             int alt122=2;
 12711  0
             switch ( input.LA(1) ) {
 12712  
             case BLANK_NODE:
 12713  
             case BLANK_NODE_LABEL:
 12714  
             case DECIMAL:
 12715  
             case DECIMAL_NEGATIVE:
 12716  
             case DECIMAL_POSITIVE:
 12717  
             case DOUBLE:
 12718  
             case DOUBLE_NEGATIVE:
 12719  
             case DOUBLE_POSITIVE:
 12720  
             case FALSE:
 12721  
             case INTEGER:
 12722  
             case INTEGER_NEGATIVE:
 12723  
             case INTEGER_POSITIVE:
 12724  
             case IRI_REF:
 12725  
             case OPEN_BRACE:
 12726  
             case OPEN_SQUARE_BRACKET:
 12727  
             case PNAME_LN:
 12728  
             case PNAME_NS:
 12729  
             case STRING_LITERAL1:
 12730  
             case STRING_LITERAL2:
 12731  
             case STRING_LITERAL_LONG1:
 12732  
             case STRING_LITERAL_LONG2:
 12733  
             case TRUE:
 12734  
             case VAR1:
 12735  
             case VAR2:
 12736  
                 {
 12737  0
                 alt122=1;
 12738  
                 }
 12739  0
                 break;
 12740  
             case COLLECTION:
 12741  
             case TRIPLES_NODE:
 12742  
                 {
 12743  0
                 alt122=2;
 12744  
                 }
 12745  0
                 break;
 12746  
             default:
 12747  0
                 NoViableAltException nvae =
 12748  
                     new NoViableAltException("", 122, 0, input);
 12749  
 
 12750  0
                 throw nvae;
 12751  
 
 12752  
             }
 12753  
 
 12754  0
             switch (alt122) {
 12755  
                 case 1 :
 12756  
                     // com\\googlecode\\sparkleg\\SparqlT.g:389:7: varOrTerm
 12757  
                     {
 12758  0
                     root_0 = (CommonTree)adaptor.nil();
 12759  
 
 12760  
 
 12761  0
                     _last = (CommonTree)input.LT(1);
 12762  0
                     pushFollow(FOLLOW_varOrTerm_in_graphNode2596);
 12763  0
                     varOrTerm320=varOrTerm();
 12764  
 
 12765  0
                     state._fsp--;
 12766  
 
 12767  0
                     adaptor.addChild(root_0, varOrTerm320.getTree());
 12768  
 
 12769  
 
 12770  
                     }
 12771  0
                     break;
 12772  
                 case 2 :
 12773  
                     // com\\googlecode\\sparkleg\\SparqlT.g:389:19: triplesNode
 12774  
                     {
 12775  0
                     root_0 = (CommonTree)adaptor.nil();
 12776  
 
 12777  
 
 12778  0
                     _last = (CommonTree)input.LT(1);
 12779  0
                     pushFollow(FOLLOW_triplesNode_in_graphNode2600);
 12780  0
                     triplesNode321=triplesNode();
 12781  
 
 12782  0
                     state._fsp--;
 12783  
 
 12784  0
                     adaptor.addChild(root_0, triplesNode321.getTree());
 12785  
 
 12786  
 
 12787  
                     }
 12788  
                     break;
 12789  
 
 12790  
             }
 12791  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 12792  
 
 12793  
         }
 12794  0
         catch (RecognitionException re) {
 12795  0
             reportError(re);
 12796  0
             recover(input,re);
 12797  
         }
 12798  
 
 12799  0
         finally {
 12800  
                 // do for sure before leaving
 12801  0
         }
 12802  0
         return retval;
 12803  
     }
 12804  
     // $ANTLR end "graphNode"
 12805  
 
 12806  
 
 12807  0
     public static class varOrTerm_return extends TreeRuleReturnScope {
 12808  
         CommonTree tree;
 12809  0
         public Object getTree() { return tree; }
 12810  
     };
 12811  
 
 12812  
 
 12813  
     // $ANTLR start "varOrTerm"
 12814  
     // com\\googlecode\\sparkleg\\SparqlT.g:392:1: varOrTerm : ( var | graphTerm | BLANK_NODE );
 12815  
     public final SparqlT.varOrTerm_return varOrTerm() throws RecognitionException {
 12816  0
         SparqlT.varOrTerm_return retval = new SparqlT.varOrTerm_return();
 12817  0
         retval.start = input.LT(1);
 12818  
 
 12819  
 
 12820  0
         CommonTree root_0 = null;
 12821  
 
 12822  0
         CommonTree _first_0 = null;
 12823  0
         CommonTree _last = null;
 12824  
 
 12825  0
         CommonTree BLANK_NODE324=null;
 12826  0
         SparqlT.var_return var322 =null;
 12827  
 
 12828  0
         SparqlT.graphTerm_return graphTerm323 =null;
 12829  
 
 12830  
 
 12831  0
         CommonTree BLANK_NODE324_tree=null;
 12832  
 
 12833  
         try {
 12834  
             // com\\googlecode\\sparkleg\\SparqlT.g:393:5: ( var | graphTerm | BLANK_NODE )
 12835  0
             int alt123=3;
 12836  0
             switch ( input.LA(1) ) {
 12837  
             case VAR1:
 12838  
             case VAR2:
 12839  
                 {
 12840  0
                 alt123=1;
 12841  
                 }
 12842  0
                 break;
 12843  
             case BLANK_NODE_LABEL:
 12844  
             case DECIMAL:
 12845  
             case DECIMAL_NEGATIVE:
 12846  
             case DECIMAL_POSITIVE:
 12847  
             case DOUBLE:
 12848  
             case DOUBLE_NEGATIVE:
 12849  
             case DOUBLE_POSITIVE:
 12850  
             case FALSE:
 12851  
             case INTEGER:
 12852  
             case INTEGER_NEGATIVE:
 12853  
             case INTEGER_POSITIVE:
 12854  
             case IRI_REF:
 12855  
             case OPEN_BRACE:
 12856  
             case OPEN_SQUARE_BRACKET:
 12857  
             case PNAME_LN:
 12858  
             case PNAME_NS:
 12859  
             case STRING_LITERAL1:
 12860  
             case STRING_LITERAL2:
 12861  
             case STRING_LITERAL_LONG1:
 12862  
             case STRING_LITERAL_LONG2:
 12863  
             case TRUE:
 12864  
                 {
 12865  0
                 alt123=2;
 12866  
                 }
 12867  0
                 break;
 12868  
             case BLANK_NODE:
 12869  
                 {
 12870  0
                 alt123=3;
 12871  
                 }
 12872  0
                 break;
 12873  
             default:
 12874  0
                 NoViableAltException nvae =
 12875  
                     new NoViableAltException("", 123, 0, input);
 12876  
 
 12877  0
                 throw nvae;
 12878  
 
 12879  
             }
 12880  
 
 12881  0
             switch (alt123) {
 12882  
                 case 1 :
 12883  
                     // com\\googlecode\\sparkleg\\SparqlT.g:393:7: var
 12884  
                     {
 12885  0
                     root_0 = (CommonTree)adaptor.nil();
 12886  
 
 12887  
 
 12888  0
                     _last = (CommonTree)input.LT(1);
 12889  0
                     pushFollow(FOLLOW_var_in_varOrTerm2617);
 12890  0
                     var322=var();
 12891  
 
 12892  0
                     state._fsp--;
 12893  
 
 12894  0
                     adaptor.addChild(root_0, var322.getTree());
 12895  
 
 12896  
 
 12897  
                     }
 12898  0
                     break;
 12899  
                 case 2 :
 12900  
                     // com\\googlecode\\sparkleg\\SparqlT.g:393:13: graphTerm
 12901  
                     {
 12902  0
                     root_0 = (CommonTree)adaptor.nil();
 12903  
 
 12904  
 
 12905  0
                     _last = (CommonTree)input.LT(1);
 12906  0
                     pushFollow(FOLLOW_graphTerm_in_varOrTerm2621);
 12907  0
                     graphTerm323=graphTerm();
 12908  
 
 12909  0
                     state._fsp--;
 12910  
 
 12911  0
                     adaptor.addChild(root_0, graphTerm323.getTree());
 12912  
 
 12913  
 
 12914  
                     }
 12915  0
                     break;
 12916  
                 case 3 :
 12917  
                     // com\\googlecode\\sparkleg\\SparqlT.g:393:25: BLANK_NODE
 12918  
                     {
 12919  0
                     root_0 = (CommonTree)adaptor.nil();
 12920  
 
 12921  
 
 12922  0
                     _last = (CommonTree)input.LT(1);
 12923  0
                     BLANK_NODE324=(CommonTree)match(input,BLANK_NODE,FOLLOW_BLANK_NODE_in_varOrTerm2625); 
 12924  0
                     BLANK_NODE324_tree = (CommonTree)adaptor.dupNode(BLANK_NODE324);
 12925  
 
 12926  
 
 12927  0
                     adaptor.addChild(root_0, BLANK_NODE324_tree);
 12928  
 
 12929  
 
 12930  
                     }
 12931  
                     break;
 12932  
 
 12933  
             }
 12934  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 12935  
 
 12936  
         }
 12937  0
         catch (RecognitionException re) {
 12938  0
             reportError(re);
 12939  0
             recover(input,re);
 12940  
         }
 12941  
 
 12942  0
         finally {
 12943  
                 // do for sure before leaving
 12944  0
         }
 12945  0
         return retval;
 12946  
     }
 12947  
     // $ANTLR end "varOrTerm"
 12948  
 
 12949  
 
 12950  0
     public static class varOrIRIref_return extends TreeRuleReturnScope {
 12951  
         CommonTree tree;
 12952  0
         public Object getTree() { return tree; }
 12953  
     };
 12954  
 
 12955  
 
 12956  
     // $ANTLR start "varOrIRIref"
 12957  
     // com\\googlecode\\sparkleg\\SparqlT.g:396:1: varOrIRIref : ( var | iriRef );
 12958  
     public final SparqlT.varOrIRIref_return varOrIRIref() throws RecognitionException {
 12959  0
         SparqlT.varOrIRIref_return retval = new SparqlT.varOrIRIref_return();
 12960  0
         retval.start = input.LT(1);
 12961  
 
 12962  
 
 12963  0
         CommonTree root_0 = null;
 12964  
 
 12965  0
         CommonTree _first_0 = null;
 12966  0
         CommonTree _last = null;
 12967  
 
 12968  0
         SparqlT.var_return var325 =null;
 12969  
 
 12970  0
         SparqlT.iriRef_return iriRef326 =null;
 12971  
 
 12972  
 
 12973  
 
 12974  
         try {
 12975  
             // com\\googlecode\\sparkleg\\SparqlT.g:397:5: ( var | iriRef )
 12976  0
             int alt124=2;
 12977  0
             switch ( input.LA(1) ) {
 12978  
             case VAR1:
 12979  
             case VAR2:
 12980  
                 {
 12981  0
                 alt124=1;
 12982  
                 }
 12983  0
                 break;
 12984  
             case IRI_REF:
 12985  
             case PNAME_LN:
 12986  
             case PNAME_NS:
 12987  
                 {
 12988  0
                 alt124=2;
 12989  
                 }
 12990  0
                 break;
 12991  
             default:
 12992  0
                 NoViableAltException nvae =
 12993  
                     new NoViableAltException("", 124, 0, input);
 12994  
 
 12995  0
                 throw nvae;
 12996  
 
 12997  
             }
 12998  
 
 12999  0
             switch (alt124) {
 13000  
                 case 1 :
 13001  
                     // com\\googlecode\\sparkleg\\SparqlT.g:397:7: var
 13002  
                     {
 13003  0
                     root_0 = (CommonTree)adaptor.nil();
 13004  
 
 13005  
 
 13006  0
                     _last = (CommonTree)input.LT(1);
 13007  0
                     pushFollow(FOLLOW_var_in_varOrIRIref2642);
 13008  0
                     var325=var();
 13009  
 
 13010  0
                     state._fsp--;
 13011  
 
 13012  0
                     adaptor.addChild(root_0, var325.getTree());
 13013  
 
 13014  
 
 13015  
                     }
 13016  0
                     break;
 13017  
                 case 2 :
 13018  
                     // com\\googlecode\\sparkleg\\SparqlT.g:397:13: iriRef
 13019  
                     {
 13020  0
                     root_0 = (CommonTree)adaptor.nil();
 13021  
 
 13022  
 
 13023  0
                     _last = (CommonTree)input.LT(1);
 13024  0
                     pushFollow(FOLLOW_iriRef_in_varOrIRIref2646);
 13025  0
                     iriRef326=iriRef();
 13026  
 
 13027  0
                     state._fsp--;
 13028  
 
 13029  0
                     adaptor.addChild(root_0, iriRef326.getTree());
 13030  
 
 13031  
 
 13032  
                     }
 13033  
                     break;
 13034  
 
 13035  
             }
 13036  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 13037  
 
 13038  
         }
 13039  0
         catch (RecognitionException re) {
 13040  0
             reportError(re);
 13041  0
             recover(input,re);
 13042  
         }
 13043  
 
 13044  0
         finally {
 13045  
                 // do for sure before leaving
 13046  0
         }
 13047  0
         return retval;
 13048  
     }
 13049  
     // $ANTLR end "varOrIRIref"
 13050  
 
 13051  
 
 13052  0
     public static class var_return extends TreeRuleReturnScope {
 13053  
         CommonTree tree;
 13054  0
         public Object getTree() { return tree; }
 13055  
     };
 13056  
 
 13057  
 
 13058  
     // $ANTLR start "var"
 13059  
     // com\\googlecode\\sparkleg\\SparqlT.g:400:1: var : ( VAR1 | VAR2 );
 13060  
     public final SparqlT.var_return var() throws RecognitionException {
 13061  0
         SparqlT.var_return retval = new SparqlT.var_return();
 13062  0
         retval.start = input.LT(1);
 13063  
 
 13064  
 
 13065  0
         CommonTree root_0 = null;
 13066  
 
 13067  0
         CommonTree _first_0 = null;
 13068  0
         CommonTree _last = null;
 13069  
 
 13070  0
         CommonTree set327=null;
 13071  
 
 13072  0
         CommonTree set327_tree=null;
 13073  
 
 13074  
         try {
 13075  
             // com\\googlecode\\sparkleg\\SparqlT.g:401:5: ( VAR1 | VAR2 )
 13076  
             // com\\googlecode\\sparkleg\\SparqlT.g:
 13077  
             {
 13078  0
             root_0 = (CommonTree)adaptor.nil();
 13079  
 
 13080  
 
 13081  0
             _last = (CommonTree)input.LT(1);
 13082  0
             set327=(CommonTree)input.LT(1);
 13083  
 
 13084  0
             if ( (input.LA(1) >= VAR1 && input.LA(1) <= VAR2) ) {
 13085  0
                 input.consume();
 13086  0
                 set327_tree = (CommonTree)adaptor.dupNode(set327);
 13087  
 
 13088  
 
 13089  0
                 adaptor.addChild(root_0, set327_tree);
 13090  
 
 13091  0
                 state.errorRecovery=false;
 13092  
             }
 13093  
             else {
 13094  0
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 13095  0
                 throw mse;
 13096  
             }
 13097  
 
 13098  
              
 13099  
 
 13100  
             }
 13101  
 
 13102  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 13103  
 
 13104  
         }
 13105  0
         catch (RecognitionException re) {
 13106  0
             reportError(re);
 13107  0
             recover(input,re);
 13108  
         }
 13109  
 
 13110  0
         finally {
 13111  
                 // do for sure before leaving
 13112  0
         }
 13113  0
         return retval;
 13114  
     }
 13115  
     // $ANTLR end "var"
 13116  
 
 13117  
 
 13118  0
     public static class graphTerm_return extends TreeRuleReturnScope {
 13119  
         CommonTree tree;
 13120  0
         public Object getTree() { return tree; }
 13121  
     };
 13122  
 
 13123  
 
 13124  
     // $ANTLR start "graphTerm"
 13125  
     // com\\googlecode\\sparkleg\\SparqlT.g:404:1: graphTerm : ( iriRef | rdfLiteral | numericLiteral | booleanLiteral | blankNode | nil );
 13126  
     public final SparqlT.graphTerm_return graphTerm() throws RecognitionException {
 13127  0
         SparqlT.graphTerm_return retval = new SparqlT.graphTerm_return();
 13128  0
         retval.start = input.LT(1);
 13129  
 
 13130  
 
 13131  0
         CommonTree root_0 = null;
 13132  
 
 13133  0
         CommonTree _first_0 = null;
 13134  0
         CommonTree _last = null;
 13135  
 
 13136  0
         SparqlT.iriRef_return iriRef328 =null;
 13137  
 
 13138  0
         SparqlT.rdfLiteral_return rdfLiteral329 =null;
 13139  
 
 13140  0
         SparqlT.numericLiteral_return numericLiteral330 =null;
 13141  
 
 13142  0
         SparqlT.booleanLiteral_return booleanLiteral331 =null;
 13143  
 
 13144  0
         SparqlT.blankNode_return blankNode332 =null;
 13145  
 
 13146  0
         SparqlT.nil_return nil333 =null;
 13147  
 
 13148  
 
 13149  
 
 13150  
         try {
 13151  
             // com\\googlecode\\sparkleg\\SparqlT.g:405:5: ( iriRef | rdfLiteral | numericLiteral | booleanLiteral | blankNode | nil )
 13152  0
             int alt125=6;
 13153  0
             switch ( input.LA(1) ) {
 13154  
             case IRI_REF:
 13155  
             case PNAME_LN:
 13156  
             case PNAME_NS:
 13157  
                 {
 13158  0
                 alt125=1;
 13159  
                 }
 13160  0
                 break;
 13161  
             case STRING_LITERAL1:
 13162  
             case STRING_LITERAL2:
 13163  
             case STRING_LITERAL_LONG1:
 13164  
             case STRING_LITERAL_LONG2:
 13165  
                 {
 13166  0
                 alt125=2;
 13167  
                 }
 13168  0
                 break;
 13169  
             case DECIMAL:
 13170  
             case DECIMAL_NEGATIVE:
 13171  
             case DECIMAL_POSITIVE:
 13172  
             case DOUBLE:
 13173  
             case DOUBLE_NEGATIVE:
 13174  
             case DOUBLE_POSITIVE:
 13175  
             case INTEGER:
 13176  
             case INTEGER_NEGATIVE:
 13177  
             case INTEGER_POSITIVE:
 13178  
                 {
 13179  0
                 alt125=3;
 13180  
                 }
 13181  0
                 break;
 13182  
             case FALSE:
 13183  
             case TRUE:
 13184  
                 {
 13185  0
                 alt125=4;
 13186  
                 }
 13187  0
                 break;
 13188  
             case BLANK_NODE_LABEL:
 13189  
             case OPEN_SQUARE_BRACKET:
 13190  
                 {
 13191  0
                 alt125=5;
 13192  
                 }
 13193  0
                 break;
 13194  
             case OPEN_BRACE:
 13195  
                 {
 13196  0
                 alt125=6;
 13197  
                 }
 13198  0
                 break;
 13199  
             default:
 13200  0
                 NoViableAltException nvae =
 13201  
                     new NoViableAltException("", 125, 0, input);
 13202  
 
 13203  0
                 throw nvae;
 13204  
 
 13205  
             }
 13206  
 
 13207  0
             switch (alt125) {
 13208  
                 case 1 :
 13209  
                     // com\\googlecode\\sparkleg\\SparqlT.g:405:7: iriRef
 13210  
                     {
 13211  0
                     root_0 = (CommonTree)adaptor.nil();
 13212  
 
 13213  
 
 13214  0
                     _last = (CommonTree)input.LT(1);
 13215  0
                     pushFollow(FOLLOW_iriRef_in_graphTerm2684);
 13216  0
                     iriRef328=iriRef();
 13217  
 
 13218  0
                     state._fsp--;
 13219  
 
 13220  0
                     adaptor.addChild(root_0, iriRef328.getTree());
 13221  
 
 13222  
 
 13223  
                     }
 13224  0
                     break;
 13225  
                 case 2 :
 13226  
                     // com\\googlecode\\sparkleg\\SparqlT.g:406:7: rdfLiteral
 13227  
                     {
 13228  0
                     root_0 = (CommonTree)adaptor.nil();
 13229  
 
 13230  
 
 13231  0
                     _last = (CommonTree)input.LT(1);
 13232  0
                     pushFollow(FOLLOW_rdfLiteral_in_graphTerm2692);
 13233  0
                     rdfLiteral329=rdfLiteral();
 13234  
 
 13235  0
                     state._fsp--;
 13236  
 
 13237  0
                     adaptor.addChild(root_0, rdfLiteral329.getTree());
 13238  
 
 13239  
 
 13240  
                     }
 13241  0
                     break;
 13242  
                 case 3 :
 13243  
                     // com\\googlecode\\sparkleg\\SparqlT.g:407:7: numericLiteral
 13244  
                     {
 13245  0
                     root_0 = (CommonTree)adaptor.nil();
 13246  
 
 13247  
 
 13248  0
                     _last = (CommonTree)input.LT(1);
 13249  0
                     pushFollow(FOLLOW_numericLiteral_in_graphTerm2700);
 13250  0
                     numericLiteral330=numericLiteral();
 13251  
 
 13252  0
                     state._fsp--;
 13253  
 
 13254  0
                     adaptor.addChild(root_0, numericLiteral330.getTree());
 13255  
 
 13256  
 
 13257  
                     }
 13258  0
                     break;
 13259  
                 case 4 :
 13260  
                     // com\\googlecode\\sparkleg\\SparqlT.g:408:7: booleanLiteral
 13261  
                     {
 13262  0
                     root_0 = (CommonTree)adaptor.nil();
 13263  
 
 13264  
 
 13265  0
                     _last = (CommonTree)input.LT(1);
 13266  0
                     pushFollow(FOLLOW_booleanLiteral_in_graphTerm2708);
 13267  0
                     booleanLiteral331=booleanLiteral();
 13268  
 
 13269  0
                     state._fsp--;
 13270  
 
 13271  0
                     adaptor.addChild(root_0, booleanLiteral331.getTree());
 13272  
 
 13273  
 
 13274  
                     }
 13275  0
                     break;
 13276  
                 case 5 :
 13277  
                     // com\\googlecode\\sparkleg\\SparqlT.g:409:7: blankNode
 13278  
                     {
 13279  0
                     root_0 = (CommonTree)adaptor.nil();
 13280  
 
 13281  
 
 13282  0
                     _last = (CommonTree)input.LT(1);
 13283  0
                     pushFollow(FOLLOW_blankNode_in_graphTerm2716);
 13284  0
                     blankNode332=blankNode();
 13285  
 
 13286  0
                     state._fsp--;
 13287  
 
 13288  0
                     adaptor.addChild(root_0, blankNode332.getTree());
 13289  
 
 13290  
 
 13291  
                     }
 13292  0
                     break;
 13293  
                 case 6 :
 13294  
                     // com\\googlecode\\sparkleg\\SparqlT.g:410:7: nil
 13295  
                     {
 13296  0
                     root_0 = (CommonTree)adaptor.nil();
 13297  
 
 13298  
 
 13299  0
                     _last = (CommonTree)input.LT(1);
 13300  0
                     pushFollow(FOLLOW_nil_in_graphTerm2724);
 13301  0
                     nil333=nil();
 13302  
 
 13303  0
                     state._fsp--;
 13304  
 
 13305  0
                     adaptor.addChild(root_0, nil333.getTree());
 13306  
 
 13307  
 
 13308  
                     }
 13309  
                     break;
 13310  
 
 13311  
             }
 13312  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 13313  
 
 13314  
         }
 13315  0
         catch (RecognitionException re) {
 13316  0
             reportError(re);
 13317  0
             recover(input,re);
 13318  
         }
 13319  
 
 13320  0
         finally {
 13321  
                 // do for sure before leaving
 13322  0
         }
 13323  0
         return retval;
 13324  
     }
 13325  
     // $ANTLR end "graphTerm"
 13326  
 
 13327  
 
 13328  0
     public static class nil_return extends TreeRuleReturnScope {
 13329  
         CommonTree tree;
 13330  0
         public Object getTree() { return tree; }
 13331  
     };
 13332  
 
 13333  
 
 13334  
     // $ANTLR start "nil"
 13335  
     // com\\googlecode\\sparkleg\\SparqlT.g:413:1: nil : OPEN_BRACE CLOSE_BRACE ;
 13336  
     public final SparqlT.nil_return nil() throws RecognitionException {
 13337  0
         SparqlT.nil_return retval = new SparqlT.nil_return();
 13338  0
         retval.start = input.LT(1);
 13339  
 
 13340  
 
 13341  0
         CommonTree root_0 = null;
 13342  
 
 13343  0
         CommonTree _first_0 = null;
 13344  0
         CommonTree _last = null;
 13345  
 
 13346  0
         CommonTree OPEN_BRACE334=null;
 13347  0
         CommonTree CLOSE_BRACE335=null;
 13348  
 
 13349  0
         CommonTree OPEN_BRACE334_tree=null;
 13350  0
         CommonTree CLOSE_BRACE335_tree=null;
 13351  
 
 13352  
         try {
 13353  
             // com\\googlecode\\sparkleg\\SparqlT.g:414:5: ( OPEN_BRACE CLOSE_BRACE )
 13354  
             // com\\googlecode\\sparkleg\\SparqlT.g:414:7: OPEN_BRACE CLOSE_BRACE
 13355  
             {
 13356  0
             root_0 = (CommonTree)adaptor.nil();
 13357  
 
 13358  
 
 13359  0
             _last = (CommonTree)input.LT(1);
 13360  0
             OPEN_BRACE334=(CommonTree)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_nil2745); 
 13361  0
             OPEN_BRACE334_tree = (CommonTree)adaptor.dupNode(OPEN_BRACE334);
 13362  
 
 13363  
 
 13364  0
             adaptor.addChild(root_0, OPEN_BRACE334_tree);
 13365  
 
 13366  
 
 13367  0
             _last = (CommonTree)input.LT(1);
 13368  0
             CLOSE_BRACE335=(CommonTree)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_nil2747); 
 13369  0
             CLOSE_BRACE335_tree = (CommonTree)adaptor.dupNode(CLOSE_BRACE335);
 13370  
 
 13371  
 
 13372  0
             adaptor.addChild(root_0, CLOSE_BRACE335_tree);
 13373  
 
 13374  
 
 13375  
             }
 13376  
 
 13377  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 13378  
 
 13379  
         }
 13380  0
         catch (RecognitionException re) {
 13381  0
             reportError(re);
 13382  0
             recover(input,re);
 13383  
         }
 13384  
 
 13385  0
         finally {
 13386  
                 // do for sure before leaving
 13387  0
         }
 13388  0
         return retval;
 13389  
     }
 13390  
     // $ANTLR end "nil"
 13391  
 
 13392  
 
 13393  0
     public static class expression_return extends TreeRuleReturnScope {
 13394  
         CommonTree tree;
 13395  0
         public Object getTree() { return tree; }
 13396  
     };
 13397  
 
 13398  
 
 13399  
     // $ANTLR start "expression"
 13400  
     // com\\googlecode\\sparkleg\\SparqlT.g:417:1: expression : ( ^( OR expression expression ) | ^( AND expression expression ) | ^( EQUAL expression expression ) | ^( NOT_EQUAL expression expression ) | ^( LESS expression expression ) | ^( GREATER expression expression ) | ^( LESS_EQUAL expression expression ) | ^( GREATER_EQUAL expression expression ) | ^( IN expression expression ) | ^( NOT IN expression expression ) | ^( PLUS expression expression ) | ^( MINUS expression expression ) | ^( ASTERISK expression expression ) | ^( DIVIDE expression expression ) | numericLiteralPositive | numericLiteralNegative | unaryExpression );
 13401  
     public final SparqlT.expression_return expression() throws RecognitionException {
 13402  0
         SparqlT.expression_return retval = new SparqlT.expression_return();
 13403  0
         retval.start = input.LT(1);
 13404  
 
 13405  
 
 13406  0
         CommonTree root_0 = null;
 13407  
 
 13408  0
         CommonTree _first_0 = null;
 13409  0
         CommonTree _last = null;
 13410  
 
 13411  0
         CommonTree OR336=null;
 13412  0
         CommonTree AND339=null;
 13413  0
         CommonTree EQUAL342=null;
 13414  0
         CommonTree NOT_EQUAL345=null;
 13415  0
         CommonTree LESS348=null;
 13416  0
         CommonTree GREATER351=null;
 13417  0
         CommonTree LESS_EQUAL354=null;
 13418  0
         CommonTree GREATER_EQUAL357=null;
 13419  0
         CommonTree IN360=null;
 13420  0
         CommonTree NOT363=null;
 13421  0
         CommonTree IN364=null;
 13422  0
         CommonTree PLUS367=null;
 13423  0
         CommonTree MINUS370=null;
 13424  0
         CommonTree ASTERISK373=null;
 13425  0
         CommonTree DIVIDE376=null;
 13426  0
         SparqlT.expression_return expression337 =null;
 13427  
 
 13428  0
         SparqlT.expression_return expression338 =null;
 13429  
 
 13430  0
         SparqlT.expression_return expression340 =null;
 13431  
 
 13432  0
         SparqlT.expression_return expression341 =null;
 13433  
 
 13434  0
         SparqlT.expression_return expression343 =null;
 13435  
 
 13436  0
         SparqlT.expression_return expression344 =null;
 13437  
 
 13438  0
         SparqlT.expression_return expression346 =null;
 13439  
 
 13440  0
         SparqlT.expression_return expression347 =null;
 13441  
 
 13442  0
         SparqlT.expression_return expression349 =null;
 13443  
 
 13444  0
         SparqlT.expression_return expression350 =null;
 13445  
 
 13446  0
         SparqlT.expression_return expression352 =null;
 13447  
 
 13448  0
         SparqlT.expression_return expression353 =null;
 13449  
 
 13450  0
         SparqlT.expression_return expression355 =null;
 13451  
 
 13452  0
         SparqlT.expression_return expression356 =null;
 13453  
 
 13454  0
         SparqlT.expression_return expression358 =null;
 13455  
 
 13456  0
         SparqlT.expression_return expression359 =null;
 13457  
 
 13458  0
         SparqlT.expression_return expression361 =null;
 13459  
 
 13460  0
         SparqlT.expression_return expression362 =null;
 13461  
 
 13462  0
         SparqlT.expression_return expression365 =null;
 13463  
 
 13464  0
         SparqlT.expression_return expression366 =null;
 13465  
 
 13466  0
         SparqlT.expression_return expression368 =null;
 13467  
 
 13468  0
         SparqlT.expression_return expression369 =null;
 13469  
 
 13470  0
         SparqlT.expression_return expression371 =null;
 13471  
 
 13472  0
         SparqlT.expression_return expression372 =null;
 13473  
 
 13474  0
         SparqlT.expression_return expression374 =null;
 13475  
 
 13476  0
         SparqlT.expression_return expression375 =null;
 13477  
 
 13478  0
         SparqlT.expression_return expression377 =null;
 13479  
 
 13480  0
         SparqlT.expression_return expression378 =null;
 13481  
 
 13482  0
         SparqlT.numericLiteralPositive_return numericLiteralPositive379 =null;
 13483  
 
 13484  0
         SparqlT.numericLiteralNegative_return numericLiteralNegative380 =null;
 13485  
 
 13486  0
         SparqlT.unaryExpression_return unaryExpression381 =null;
 13487  
 
 13488  
 
 13489  0
         CommonTree OR336_tree=null;
 13490  0
         CommonTree AND339_tree=null;
 13491  0
         CommonTree EQUAL342_tree=null;
 13492  0
         CommonTree NOT_EQUAL345_tree=null;
 13493  0
         CommonTree LESS348_tree=null;
 13494  0
         CommonTree GREATER351_tree=null;
 13495  0
         CommonTree LESS_EQUAL354_tree=null;
 13496  0
         CommonTree GREATER_EQUAL357_tree=null;
 13497  0
         CommonTree IN360_tree=null;
 13498  0
         CommonTree NOT363_tree=null;
 13499  0
         CommonTree IN364_tree=null;
 13500  0
         CommonTree PLUS367_tree=null;
 13501  0
         CommonTree MINUS370_tree=null;
 13502  0
         CommonTree ASTERISK373_tree=null;
 13503  0
         CommonTree DIVIDE376_tree=null;
 13504  
 
 13505  
         try {
 13506  
             // com\\googlecode\\sparkleg\\SparqlT.g:418:5: ( ^( OR expression expression ) | ^( AND expression expression ) | ^( EQUAL expression expression ) | ^( NOT_EQUAL expression expression ) | ^( LESS expression expression ) | ^( GREATER expression expression ) | ^( LESS_EQUAL expression expression ) | ^( GREATER_EQUAL expression expression ) | ^( IN expression expression ) | ^( NOT IN expression expression ) | ^( PLUS expression expression ) | ^( MINUS expression expression ) | ^( ASTERISK expression expression ) | ^( DIVIDE expression expression ) | numericLiteralPositive | numericLiteralNegative | unaryExpression )
 13507  0
             int alt126=17;
 13508  0
             switch ( input.LA(1) ) {
 13509  
             case OR:
 13510  
                 {
 13511  0
                 alt126=1;
 13512  
                 }
 13513  0
                 break;
 13514  
             case AND:
 13515  
                 {
 13516  0
                 alt126=2;
 13517  
                 }
 13518  0
                 break;
 13519  
             case EQUAL:
 13520  
                 {
 13521  0
                 alt126=3;
 13522  
                 }
 13523  0
                 break;
 13524  
             case NOT_EQUAL:
 13525  
                 {
 13526  0
                 alt126=4;
 13527  
                 }
 13528  0
                 break;
 13529  
             case LESS:
 13530  
                 {
 13531  0
                 alt126=5;
 13532  
                 }
 13533  0
                 break;
 13534  
             case GREATER:
 13535  
                 {
 13536  0
                 alt126=6;
 13537  
                 }
 13538  0
                 break;
 13539  
             case LESS_EQUAL:
 13540  
                 {
 13541  0
                 alt126=7;
 13542  
                 }
 13543  0
                 break;
 13544  
             case GREATER_EQUAL:
 13545  
                 {
 13546  0
                 alt126=8;
 13547  
                 }
 13548  0
                 break;
 13549  
             case IN:
 13550  
                 {
 13551  0
                 alt126=9;
 13552  
                 }
 13553  0
                 break;
 13554  
             case NOT:
 13555  
                 {
 13556  0
                 alt126=10;
 13557  
                 }
 13558  0
                 break;
 13559  
             case PLUS:
 13560  
                 {
 13561  0
                 alt126=11;
 13562  
                 }
 13563  0
                 break;
 13564  
             case MINUS:
 13565  
                 {
 13566  0
                 alt126=12;
 13567  
                 }
 13568  0
                 break;
 13569  
             case ASTERISK:
 13570  
                 {
 13571  0
                 alt126=13;
 13572  
                 }
 13573  0
                 break;
 13574  
             case DIVIDE:
 13575  
                 {
 13576  0
                 alt126=14;
 13577  
                 }
 13578  0
                 break;
 13579  
             case DECIMAL_POSITIVE:
 13580  
             case DOUBLE_POSITIVE:
 13581  
             case INTEGER_POSITIVE:
 13582  
                 {
 13583  0
                 alt126=15;
 13584  
                 }
 13585  0
                 break;
 13586  
             case DECIMAL_NEGATIVE:
 13587  
             case DOUBLE_NEGATIVE:
 13588  
             case INTEGER_NEGATIVE:
 13589  
                 {
 13590  0
                 alt126=16;
 13591  
                 }
 13592  0
                 break;
 13593  
             case UNARY:
 13594  
                 {
 13595  0
                 alt126=17;
 13596  
                 }
 13597  0
                 break;
 13598  
             default:
 13599  0
                 NoViableAltException nvae =
 13600  
                     new NoViableAltException("", 126, 0, input);
 13601  
 
 13602  0
                 throw nvae;
 13603  
 
 13604  
             }
 13605  
 
 13606  0
             switch (alt126) {
 13607  
                 case 1 :
 13608  
                     // com\\googlecode\\sparkleg\\SparqlT.g:418:7: ^( OR expression expression )
 13609  
                     {
 13610  0
                     root_0 = (CommonTree)adaptor.nil();
 13611  
 
 13612  
 
 13613  0
                     _last = (CommonTree)input.LT(1);
 13614  
                     {
 13615  0
                     CommonTree _save_last_1 = _last;
 13616  0
                     CommonTree _first_1 = null;
 13617  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 13618  0
                     _last = (CommonTree)input.LT(1);
 13619  0
                     OR336=(CommonTree)match(input,OR,FOLLOW_OR_in_expression2765); 
 13620  0
                     OR336_tree = (CommonTree)adaptor.dupNode(OR336);
 13621  
 
 13622  
 
 13623  0
                     root_1 = (CommonTree)adaptor.becomeRoot(OR336_tree, root_1);
 13624  
 
 13625  
 
 13626  0
                     match(input, Token.DOWN, null); 
 13627  0
                     _last = (CommonTree)input.LT(1);
 13628  0
                     pushFollow(FOLLOW_expression_in_expression2767);
 13629  0
                     expression337=expression();
 13630  
 
 13631  0
                     state._fsp--;
 13632  
 
 13633  0
                     adaptor.addChild(root_1, expression337.getTree());
 13634  
 
 13635  
 
 13636  0
                     _last = (CommonTree)input.LT(1);
 13637  0
                     pushFollow(FOLLOW_expression_in_expression2769);
 13638  0
                     expression338=expression();
 13639  
 
 13640  0
                     state._fsp--;
 13641  
 
 13642  0
                     adaptor.addChild(root_1, expression338.getTree());
 13643  
 
 13644  
 
 13645  0
                     match(input, Token.UP, null); 
 13646  0
                     adaptor.addChild(root_0, root_1);
 13647  0
                     _last = _save_last_1;
 13648  
                     }
 13649  
 
 13650  
 
 13651  
                     }
 13652  0
                     break;
 13653  
                 case 2 :
 13654  
                     // com\\googlecode\\sparkleg\\SparqlT.g:419:7: ^( AND expression expression )
 13655  
                     {
 13656  0
                     root_0 = (CommonTree)adaptor.nil();
 13657  
 
 13658  
 
 13659  0
                     _last = (CommonTree)input.LT(1);
 13660  
                     {
 13661  0
                     CommonTree _save_last_1 = _last;
 13662  0
                     CommonTree _first_1 = null;
 13663  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 13664  0
                     _last = (CommonTree)input.LT(1);
 13665  0
                     AND339=(CommonTree)match(input,AND,FOLLOW_AND_in_expression2779); 
 13666  0
                     AND339_tree = (CommonTree)adaptor.dupNode(AND339);
 13667  
 
 13668  
 
 13669  0
                     root_1 = (CommonTree)adaptor.becomeRoot(AND339_tree, root_1);
 13670  
 
 13671  
 
 13672  0
                     match(input, Token.DOWN, null); 
 13673  0
                     _last = (CommonTree)input.LT(1);
 13674  0
                     pushFollow(FOLLOW_expression_in_expression2781);
 13675  0
                     expression340=expression();
 13676  
 
 13677  0
                     state._fsp--;
 13678  
 
 13679  0
                     adaptor.addChild(root_1, expression340.getTree());
 13680  
 
 13681  
 
 13682  0
                     _last = (CommonTree)input.LT(1);
 13683  0
                     pushFollow(FOLLOW_expression_in_expression2783);
 13684  0
                     expression341=expression();
 13685  
 
 13686  0
                     state._fsp--;
 13687  
 
 13688  0
                     adaptor.addChild(root_1, expression341.getTree());
 13689  
 
 13690  
 
 13691  0
                     match(input, Token.UP, null); 
 13692  0
                     adaptor.addChild(root_0, root_1);
 13693  0
                     _last = _save_last_1;
 13694  
                     }
 13695  
 
 13696  
 
 13697  
                     }
 13698  0
                     break;
 13699  
                 case 3 :
 13700  
                     // com\\googlecode\\sparkleg\\SparqlT.g:420:7: ^( EQUAL expression expression )
 13701  
                     {
 13702  0
                     root_0 = (CommonTree)adaptor.nil();
 13703  
 
 13704  
 
 13705  0
                     _last = (CommonTree)input.LT(1);
 13706  
                     {
 13707  0
                     CommonTree _save_last_1 = _last;
 13708  0
                     CommonTree _first_1 = null;
 13709  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 13710  0
                     _last = (CommonTree)input.LT(1);
 13711  0
                     EQUAL342=(CommonTree)match(input,EQUAL,FOLLOW_EQUAL_in_expression2793); 
 13712  0
                     EQUAL342_tree = (CommonTree)adaptor.dupNode(EQUAL342);
 13713  
 
 13714  
 
 13715  0
                     root_1 = (CommonTree)adaptor.becomeRoot(EQUAL342_tree, root_1);
 13716  
 
 13717  
 
 13718  0
                     match(input, Token.DOWN, null); 
 13719  0
                     _last = (CommonTree)input.LT(1);
 13720  0
                     pushFollow(FOLLOW_expression_in_expression2795);
 13721  0
                     expression343=expression();
 13722  
 
 13723  0
                     state._fsp--;
 13724  
 
 13725  0
                     adaptor.addChild(root_1, expression343.getTree());
 13726  
 
 13727  
 
 13728  0
                     _last = (CommonTree)input.LT(1);
 13729  0
                     pushFollow(FOLLOW_expression_in_expression2797);
 13730  0
                     expression344=expression();
 13731  
 
 13732  0
                     state._fsp--;
 13733  
 
 13734  0
                     adaptor.addChild(root_1, expression344.getTree());
 13735  
 
 13736  
 
 13737  0
                     match(input, Token.UP, null); 
 13738  0
                     adaptor.addChild(root_0, root_1);
 13739  0
                     _last = _save_last_1;
 13740  
                     }
 13741  
 
 13742  
 
 13743  
                     }
 13744  0
                     break;
 13745  
                 case 4 :
 13746  
                     // com\\googlecode\\sparkleg\\SparqlT.g:421:7: ^( NOT_EQUAL expression expression )
 13747  
                     {
 13748  0
                     root_0 = (CommonTree)adaptor.nil();
 13749  
 
 13750  
 
 13751  0
                     _last = (CommonTree)input.LT(1);
 13752  
                     {
 13753  0
                     CommonTree _save_last_1 = _last;
 13754  0
                     CommonTree _first_1 = null;
 13755  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 13756  0
                     _last = (CommonTree)input.LT(1);
 13757  0
                     NOT_EQUAL345=(CommonTree)match(input,NOT_EQUAL,FOLLOW_NOT_EQUAL_in_expression2809); 
 13758  0
                     NOT_EQUAL345_tree = (CommonTree)adaptor.dupNode(NOT_EQUAL345);
 13759  
 
 13760  
 
 13761  0
                     root_1 = (CommonTree)adaptor.becomeRoot(NOT_EQUAL345_tree, root_1);
 13762  
 
 13763  
 
 13764  0
                     match(input, Token.DOWN, null); 
 13765  0
                     _last = (CommonTree)input.LT(1);
 13766  0
                     pushFollow(FOLLOW_expression_in_expression2811);
 13767  0
                     expression346=expression();
 13768  
 
 13769  0
                     state._fsp--;
 13770  
 
 13771  0
                     adaptor.addChild(root_1, expression346.getTree());
 13772  
 
 13773  
 
 13774  0
                     _last = (CommonTree)input.LT(1);
 13775  0
                     pushFollow(FOLLOW_expression_in_expression2813);
 13776  0
                     expression347=expression();
 13777  
 
 13778  0
                     state._fsp--;
 13779  
 
 13780  0
                     adaptor.addChild(root_1, expression347.getTree());
 13781  
 
 13782  
 
 13783  0
                     match(input, Token.UP, null); 
 13784  0
                     adaptor.addChild(root_0, root_1);
 13785  0
                     _last = _save_last_1;
 13786  
                     }
 13787  
 
 13788  
 
 13789  
                     }
 13790  0
                     break;
 13791  
                 case 5 :
 13792  
                     // com\\googlecode\\sparkleg\\SparqlT.g:422:7: ^( LESS expression expression )
 13793  
                     {
 13794  0
                     root_0 = (CommonTree)adaptor.nil();
 13795  
 
 13796  
 
 13797  0
                     _last = (CommonTree)input.LT(1);
 13798  
                     {
 13799  0
                     CommonTree _save_last_1 = _last;
 13800  0
                     CommonTree _first_1 = null;
 13801  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 13802  0
                     _last = (CommonTree)input.LT(1);
 13803  0
                     LESS348=(CommonTree)match(input,LESS,FOLLOW_LESS_in_expression2823); 
 13804  0
                     LESS348_tree = (CommonTree)adaptor.dupNode(LESS348);
 13805  
 
 13806  
 
 13807  0
                     root_1 = (CommonTree)adaptor.becomeRoot(LESS348_tree, root_1);
 13808  
 
 13809  
 
 13810  0
                     match(input, Token.DOWN, null); 
 13811  0
                     _last = (CommonTree)input.LT(1);
 13812  0
                     pushFollow(FOLLOW_expression_in_expression2825);
 13813  0
                     expression349=expression();
 13814  
 
 13815  0
                     state._fsp--;
 13816  
 
 13817  0
                     adaptor.addChild(root_1, expression349.getTree());
 13818  
 
 13819  
 
 13820  0
                     _last = (CommonTree)input.LT(1);
 13821  0
                     pushFollow(FOLLOW_expression_in_expression2827);
 13822  0
                     expression350=expression();
 13823  
 
 13824  0
                     state._fsp--;
 13825  
 
 13826  0
                     adaptor.addChild(root_1, expression350.getTree());
 13827  
 
 13828  
 
 13829  0
                     match(input, Token.UP, null); 
 13830  0
                     adaptor.addChild(root_0, root_1);
 13831  0
                     _last = _save_last_1;
 13832  
                     }
 13833  
 
 13834  
 
 13835  
                     }
 13836  0
                     break;
 13837  
                 case 6 :
 13838  
                     // com\\googlecode\\sparkleg\\SparqlT.g:423:7: ^( GREATER expression expression )
 13839  
                     {
 13840  0
                     root_0 = (CommonTree)adaptor.nil();
 13841  
 
 13842  
 
 13843  0
                     _last = (CommonTree)input.LT(1);
 13844  
                     {
 13845  0
                     CommonTree _save_last_1 = _last;
 13846  0
                     CommonTree _first_1 = null;
 13847  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 13848  0
                     _last = (CommonTree)input.LT(1);
 13849  0
                     GREATER351=(CommonTree)match(input,GREATER,FOLLOW_GREATER_in_expression2837); 
 13850  0
                     GREATER351_tree = (CommonTree)adaptor.dupNode(GREATER351);
 13851  
 
 13852  
 
 13853  0
                     root_1 = (CommonTree)adaptor.becomeRoot(GREATER351_tree, root_1);
 13854  
 
 13855  
 
 13856  0
                     match(input, Token.DOWN, null); 
 13857  0
                     _last = (CommonTree)input.LT(1);
 13858  0
                     pushFollow(FOLLOW_expression_in_expression2839);
 13859  0
                     expression352=expression();
 13860  
 
 13861  0
                     state._fsp--;
 13862  
 
 13863  0
                     adaptor.addChild(root_1, expression352.getTree());
 13864  
 
 13865  
 
 13866  0
                     _last = (CommonTree)input.LT(1);
 13867  0
                     pushFollow(FOLLOW_expression_in_expression2841);
 13868  0
                     expression353=expression();
 13869  
 
 13870  0
                     state._fsp--;
 13871  
 
 13872  0
                     adaptor.addChild(root_1, expression353.getTree());
 13873  
 
 13874  
 
 13875  0
                     match(input, Token.UP, null); 
 13876  0
                     adaptor.addChild(root_0, root_1);
 13877  0
                     _last = _save_last_1;
 13878  
                     }
 13879  
 
 13880  
 
 13881  
                     }
 13882  0
                     break;
 13883  
                 case 7 :
 13884  
                     // com\\googlecode\\sparkleg\\SparqlT.g:424:7: ^( LESS_EQUAL expression expression )
 13885  
                     {
 13886  0
                     root_0 = (CommonTree)adaptor.nil();
 13887  
 
 13888  
 
 13889  0
                     _last = (CommonTree)input.LT(1);
 13890  
                     {
 13891  0
                     CommonTree _save_last_1 = _last;
 13892  0
                     CommonTree _first_1 = null;
 13893  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 13894  0
                     _last = (CommonTree)input.LT(1);
 13895  0
                     LESS_EQUAL354=(CommonTree)match(input,LESS_EQUAL,FOLLOW_LESS_EQUAL_in_expression2851); 
 13896  0
                     LESS_EQUAL354_tree = (CommonTree)adaptor.dupNode(LESS_EQUAL354);
 13897  
 
 13898  
 
 13899  0
                     root_1 = (CommonTree)adaptor.becomeRoot(LESS_EQUAL354_tree, root_1);
 13900  
 
 13901  
 
 13902  0
                     match(input, Token.DOWN, null); 
 13903  0
                     _last = (CommonTree)input.LT(1);
 13904  0
                     pushFollow(FOLLOW_expression_in_expression2853);
 13905  0
                     expression355=expression();
 13906  
 
 13907  0
                     state._fsp--;
 13908  
 
 13909  0
                     adaptor.addChild(root_1, expression355.getTree());
 13910  
 
 13911  
 
 13912  0
                     _last = (CommonTree)input.LT(1);
 13913  0
                     pushFollow(FOLLOW_expression_in_expression2855);
 13914  0
                     expression356=expression();
 13915  
 
 13916  0
                     state._fsp--;
 13917  
 
 13918  0
                     adaptor.addChild(root_1, expression356.getTree());
 13919  
 
 13920  
 
 13921  0
                     match(input, Token.UP, null); 
 13922  0
                     adaptor.addChild(root_0, root_1);
 13923  0
                     _last = _save_last_1;
 13924  
                     }
 13925  
 
 13926  
 
 13927  
                     }
 13928  0
                     break;
 13929  
                 case 8 :
 13930  
                     // com\\googlecode\\sparkleg\\SparqlT.g:425:7: ^( GREATER_EQUAL expression expression )
 13931  
                     {
 13932  0
                     root_0 = (CommonTree)adaptor.nil();
 13933  
 
 13934  
 
 13935  0
                     _last = (CommonTree)input.LT(1);
 13936  
                     {
 13937  0
                     CommonTree _save_last_1 = _last;
 13938  0
                     CommonTree _first_1 = null;
 13939  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 13940  0
                     _last = (CommonTree)input.LT(1);
 13941  0
                     GREATER_EQUAL357=(CommonTree)match(input,GREATER_EQUAL,FOLLOW_GREATER_EQUAL_in_expression2865); 
 13942  0
                     GREATER_EQUAL357_tree = (CommonTree)adaptor.dupNode(GREATER_EQUAL357);
 13943  
 
 13944  
 
 13945  0
                     root_1 = (CommonTree)adaptor.becomeRoot(GREATER_EQUAL357_tree, root_1);
 13946  
 
 13947  
 
 13948  0
                     match(input, Token.DOWN, null); 
 13949  0
                     _last = (CommonTree)input.LT(1);
 13950  0
                     pushFollow(FOLLOW_expression_in_expression2867);
 13951  0
                     expression358=expression();
 13952  
 
 13953  0
                     state._fsp--;
 13954  
 
 13955  0
                     adaptor.addChild(root_1, expression358.getTree());
 13956  
 
 13957  
 
 13958  0
                     _last = (CommonTree)input.LT(1);
 13959  0
                     pushFollow(FOLLOW_expression_in_expression2869);
 13960  0
                     expression359=expression();
 13961  
 
 13962  0
                     state._fsp--;
 13963  
 
 13964  0
                     adaptor.addChild(root_1, expression359.getTree());
 13965  
 
 13966  
 
 13967  0
                     match(input, Token.UP, null); 
 13968  0
                     adaptor.addChild(root_0, root_1);
 13969  0
                     _last = _save_last_1;
 13970  
                     }
 13971  
 
 13972  
 
 13973  
                     }
 13974  0
                     break;
 13975  
                 case 9 :
 13976  
                     // com\\googlecode\\sparkleg\\SparqlT.g:426:7: ^( IN expression expression )
 13977  
                     {
 13978  0
                     root_0 = (CommonTree)adaptor.nil();
 13979  
 
 13980  
 
 13981  0
                     _last = (CommonTree)input.LT(1);
 13982  
                     {
 13983  0
                     CommonTree _save_last_1 = _last;
 13984  0
                     CommonTree _first_1 = null;
 13985  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 13986  0
                     _last = (CommonTree)input.LT(1);
 13987  0
                     IN360=(CommonTree)match(input,IN,FOLLOW_IN_in_expression2881); 
 13988  0
                     IN360_tree = (CommonTree)adaptor.dupNode(IN360);
 13989  
 
 13990  
 
 13991  0
                     root_1 = (CommonTree)adaptor.becomeRoot(IN360_tree, root_1);
 13992  
 
 13993  
 
 13994  0
                     match(input, Token.DOWN, null); 
 13995  0
                     _last = (CommonTree)input.LT(1);
 13996  0
                     pushFollow(FOLLOW_expression_in_expression2883);
 13997  0
                     expression361=expression();
 13998  
 
 13999  0
                     state._fsp--;
 14000  
 
 14001  0
                     adaptor.addChild(root_1, expression361.getTree());
 14002  
 
 14003  
 
 14004  0
                     _last = (CommonTree)input.LT(1);
 14005  0
                     pushFollow(FOLLOW_expression_in_expression2885);
 14006  0
                     expression362=expression();
 14007  
 
 14008  0
                     state._fsp--;
 14009  
 
 14010  0
                     adaptor.addChild(root_1, expression362.getTree());
 14011  
 
 14012  
 
 14013  0
                     match(input, Token.UP, null); 
 14014  0
                     adaptor.addChild(root_0, root_1);
 14015  0
                     _last = _save_last_1;
 14016  
                     }
 14017  
 
 14018  
 
 14019  
                     }
 14020  0
                     break;
 14021  
                 case 10 :
 14022  
                     // com\\googlecode\\sparkleg\\SparqlT.g:427:7: ^( NOT IN expression expression )
 14023  
                     {
 14024  0
                     root_0 = (CommonTree)adaptor.nil();
 14025  
 
 14026  
 
 14027  0
                     _last = (CommonTree)input.LT(1);
 14028  
                     {
 14029  0
                     CommonTree _save_last_1 = _last;
 14030  0
                     CommonTree _first_1 = null;
 14031  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 14032  0
                     _last = (CommonTree)input.LT(1);
 14033  0
                     NOT363=(CommonTree)match(input,NOT,FOLLOW_NOT_in_expression2895); 
 14034  0
                     NOT363_tree = (CommonTree)adaptor.dupNode(NOT363);
 14035  
 
 14036  
 
 14037  0
                     root_1 = (CommonTree)adaptor.becomeRoot(NOT363_tree, root_1);
 14038  
 
 14039  
 
 14040  0
                     match(input, Token.DOWN, null); 
 14041  0
                     _last = (CommonTree)input.LT(1);
 14042  0
                     IN364=(CommonTree)match(input,IN,FOLLOW_IN_in_expression2897); 
 14043  0
                     IN364_tree = (CommonTree)adaptor.dupNode(IN364);
 14044  
 
 14045  
 
 14046  0
                     adaptor.addChild(root_1, IN364_tree);
 14047  
 
 14048  
 
 14049  0
                     _last = (CommonTree)input.LT(1);
 14050  0
                     pushFollow(FOLLOW_expression_in_expression2899);
 14051  0
                     expression365=expression();
 14052  
 
 14053  0
                     state._fsp--;
 14054  
 
 14055  0
                     adaptor.addChild(root_1, expression365.getTree());
 14056  
 
 14057  
 
 14058  0
                     _last = (CommonTree)input.LT(1);
 14059  0
                     pushFollow(FOLLOW_expression_in_expression2901);
 14060  0
                     expression366=expression();
 14061  
 
 14062  0
                     state._fsp--;
 14063  
 
 14064  0
                     adaptor.addChild(root_1, expression366.getTree());
 14065  
 
 14066  
 
 14067  0
                     match(input, Token.UP, null); 
 14068  0
                     adaptor.addChild(root_0, root_1);
 14069  0
                     _last = _save_last_1;
 14070  
                     }
 14071  
 
 14072  
 
 14073  
                     }
 14074  0
                     break;
 14075  
                 case 11 :
 14076  
                     // com\\googlecode\\sparkleg\\SparqlT.g:428:7: ^( PLUS expression expression )
 14077  
                     {
 14078  0
                     root_0 = (CommonTree)adaptor.nil();
 14079  
 
 14080  
 
 14081  0
                     _last = (CommonTree)input.LT(1);
 14082  
                     {
 14083  0
                     CommonTree _save_last_1 = _last;
 14084  0
                     CommonTree _first_1 = null;
 14085  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 14086  0
                     _last = (CommonTree)input.LT(1);
 14087  0
                     PLUS367=(CommonTree)match(input,PLUS,FOLLOW_PLUS_in_expression2911); 
 14088  0
                     PLUS367_tree = (CommonTree)adaptor.dupNode(PLUS367);
 14089  
 
 14090  
 
 14091  0
                     root_1 = (CommonTree)adaptor.becomeRoot(PLUS367_tree, root_1);
 14092  
 
 14093  
 
 14094  0
                     match(input, Token.DOWN, null); 
 14095  0
                     _last = (CommonTree)input.LT(1);
 14096  0
                     pushFollow(FOLLOW_expression_in_expression2913);
 14097  0
                     expression368=expression();
 14098  
 
 14099  0
                     state._fsp--;
 14100  
 
 14101  0
                     adaptor.addChild(root_1, expression368.getTree());
 14102  
 
 14103  
 
 14104  0
                     _last = (CommonTree)input.LT(1);
 14105  0
                     pushFollow(FOLLOW_expression_in_expression2915);
 14106  0
                     expression369=expression();
 14107  
 
 14108  0
                     state._fsp--;
 14109  
 
 14110  0
                     adaptor.addChild(root_1, expression369.getTree());
 14111  
 
 14112  
 
 14113  0
                     match(input, Token.UP, null); 
 14114  0
                     adaptor.addChild(root_0, root_1);
 14115  0
                     _last = _save_last_1;
 14116  
                     }
 14117  
 
 14118  
 
 14119  
                     }
 14120  0
                     break;
 14121  
                 case 12 :
 14122  
                     // com\\googlecode\\sparkleg\\SparqlT.g:429:7: ^( MINUS expression expression )
 14123  
                     {
 14124  0
                     root_0 = (CommonTree)adaptor.nil();
 14125  
 
 14126  
 
 14127  0
                     _last = (CommonTree)input.LT(1);
 14128  
                     {
 14129  0
                     CommonTree _save_last_1 = _last;
 14130  0
                     CommonTree _first_1 = null;
 14131  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 14132  0
                     _last = (CommonTree)input.LT(1);
 14133  0
                     MINUS370=(CommonTree)match(input,MINUS,FOLLOW_MINUS_in_expression2925); 
 14134  0
                     MINUS370_tree = (CommonTree)adaptor.dupNode(MINUS370);
 14135  
 
 14136  
 
 14137  0
                     root_1 = (CommonTree)adaptor.becomeRoot(MINUS370_tree, root_1);
 14138  
 
 14139  
 
 14140  0
                     match(input, Token.DOWN, null); 
 14141  0
                     _last = (CommonTree)input.LT(1);
 14142  0
                     pushFollow(FOLLOW_expression_in_expression2927);
 14143  0
                     expression371=expression();
 14144  
 
 14145  0
                     state._fsp--;
 14146  
 
 14147  0
                     adaptor.addChild(root_1, expression371.getTree());
 14148  
 
 14149  
 
 14150  0
                     _last = (CommonTree)input.LT(1);
 14151  0
                     pushFollow(FOLLOW_expression_in_expression2929);
 14152  0
                     expression372=expression();
 14153  
 
 14154  0
                     state._fsp--;
 14155  
 
 14156  0
                     adaptor.addChild(root_1, expression372.getTree());
 14157  
 
 14158  
 
 14159  0
                     match(input, Token.UP, null); 
 14160  0
                     adaptor.addChild(root_0, root_1);
 14161  0
                     _last = _save_last_1;
 14162  
                     }
 14163  
 
 14164  
 
 14165  
                     }
 14166  0
                     break;
 14167  
                 case 13 :
 14168  
                     // com\\googlecode\\sparkleg\\SparqlT.g:430:7: ^( ASTERISK expression expression )
 14169  
                     {
 14170  0
                     root_0 = (CommonTree)adaptor.nil();
 14171  
 
 14172  
 
 14173  0
                     _last = (CommonTree)input.LT(1);
 14174  
                     {
 14175  0
                     CommonTree _save_last_1 = _last;
 14176  0
                     CommonTree _first_1 = null;
 14177  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 14178  0
                     _last = (CommonTree)input.LT(1);
 14179  0
                     ASTERISK373=(CommonTree)match(input,ASTERISK,FOLLOW_ASTERISK_in_expression2940); 
 14180  0
                     ASTERISK373_tree = (CommonTree)adaptor.dupNode(ASTERISK373);
 14181  
 
 14182  
 
 14183  0
                     root_1 = (CommonTree)adaptor.becomeRoot(ASTERISK373_tree, root_1);
 14184  
 
 14185  
 
 14186  0
                     match(input, Token.DOWN, null); 
 14187  0
                     _last = (CommonTree)input.LT(1);
 14188  0
                     pushFollow(FOLLOW_expression_in_expression2942);
 14189  0
                     expression374=expression();
 14190  
 
 14191  0
                     state._fsp--;
 14192  
 
 14193  0
                     adaptor.addChild(root_1, expression374.getTree());
 14194  
 
 14195  
 
 14196  0
                     _last = (CommonTree)input.LT(1);
 14197  0
                     pushFollow(FOLLOW_expression_in_expression2944);
 14198  0
                     expression375=expression();
 14199  
 
 14200  0
                     state._fsp--;
 14201  
 
 14202  0
                     adaptor.addChild(root_1, expression375.getTree());
 14203  
 
 14204  
 
 14205  0
                     match(input, Token.UP, null); 
 14206  0
                     adaptor.addChild(root_0, root_1);
 14207  0
                     _last = _save_last_1;
 14208  
                     }
 14209  
 
 14210  
 
 14211  
                     }
 14212  0
                     break;
 14213  
                 case 14 :
 14214  
                     // com\\googlecode\\sparkleg\\SparqlT.g:431:7: ^( DIVIDE expression expression )
 14215  
                     {
 14216  0
                     root_0 = (CommonTree)adaptor.nil();
 14217  
 
 14218  
 
 14219  0
                     _last = (CommonTree)input.LT(1);
 14220  
                     {
 14221  0
                     CommonTree _save_last_1 = _last;
 14222  0
                     CommonTree _first_1 = null;
 14223  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 14224  0
                     _last = (CommonTree)input.LT(1);
 14225  0
                     DIVIDE376=(CommonTree)match(input,DIVIDE,FOLLOW_DIVIDE_in_expression2954); 
 14226  0
                     DIVIDE376_tree = (CommonTree)adaptor.dupNode(DIVIDE376);
 14227  
 
 14228  
 
 14229  0
                     root_1 = (CommonTree)adaptor.becomeRoot(DIVIDE376_tree, root_1);
 14230  
 
 14231  
 
 14232  0
                     match(input, Token.DOWN, null); 
 14233  0
                     _last = (CommonTree)input.LT(1);
 14234  0
                     pushFollow(FOLLOW_expression_in_expression2956);
 14235  0
                     expression377=expression();
 14236  
 
 14237  0
                     state._fsp--;
 14238  
 
 14239  0
                     adaptor.addChild(root_1, expression377.getTree());
 14240  
 
 14241  
 
 14242  0
                     _last = (CommonTree)input.LT(1);
 14243  0
                     pushFollow(FOLLOW_expression_in_expression2958);
 14244  0
                     expression378=expression();
 14245  
 
 14246  0
                     state._fsp--;
 14247  
 
 14248  0
                     adaptor.addChild(root_1, expression378.getTree());
 14249  
 
 14250  
 
 14251  0
                     match(input, Token.UP, null); 
 14252  0
                     adaptor.addChild(root_0, root_1);
 14253  0
                     _last = _save_last_1;
 14254  
                     }
 14255  
 
 14256  
 
 14257  
                     }
 14258  0
                     break;
 14259  
                 case 15 :
 14260  
                     // com\\googlecode\\sparkleg\\SparqlT.g:432:7: numericLiteralPositive
 14261  
                     {
 14262  0
                     root_0 = (CommonTree)adaptor.nil();
 14263  
 
 14264  
 
 14265  0
                     _last = (CommonTree)input.LT(1);
 14266  0
                     pushFollow(FOLLOW_numericLiteralPositive_in_expression2967);
 14267  0
                     numericLiteralPositive379=numericLiteralPositive();
 14268  
 
 14269  0
                     state._fsp--;
 14270  
 
 14271  0
                     adaptor.addChild(root_0, numericLiteralPositive379.getTree());
 14272  
 
 14273  
 
 14274  
                     }
 14275  0
                     break;
 14276  
                 case 16 :
 14277  
                     // com\\googlecode\\sparkleg\\SparqlT.g:433:7: numericLiteralNegative
 14278  
                     {
 14279  0
                     root_0 = (CommonTree)adaptor.nil();
 14280  
 
 14281  
 
 14282  0
                     _last = (CommonTree)input.LT(1);
 14283  0
                     pushFollow(FOLLOW_numericLiteralNegative_in_expression2975);
 14284  0
                     numericLiteralNegative380=numericLiteralNegative();
 14285  
 
 14286  0
                     state._fsp--;
 14287  
 
 14288  0
                     adaptor.addChild(root_0, numericLiteralNegative380.getTree());
 14289  
 
 14290  
 
 14291  
                     }
 14292  0
                     break;
 14293  
                 case 17 :
 14294  
                     // com\\googlecode\\sparkleg\\SparqlT.g:434:7: unaryExpression
 14295  
                     {
 14296  0
                     root_0 = (CommonTree)adaptor.nil();
 14297  
 
 14298  
 
 14299  0
                     _last = (CommonTree)input.LT(1);
 14300  0
                     pushFollow(FOLLOW_unaryExpression_in_expression2983);
 14301  0
                     unaryExpression381=unaryExpression();
 14302  
 
 14303  0
                     state._fsp--;
 14304  
 
 14305  0
                     adaptor.addChild(root_0, unaryExpression381.getTree());
 14306  
 
 14307  
 
 14308  
                     }
 14309  
                     break;
 14310  
 
 14311  
             }
 14312  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 14313  
 
 14314  
         }
 14315  0
         catch (RecognitionException re) {
 14316  0
             reportError(re);
 14317  0
             recover(input,re);
 14318  
         }
 14319  
 
 14320  0
         finally {
 14321  
                 // do for sure before leaving
 14322  0
         }
 14323  0
         return retval;
 14324  
     }
 14325  
     // $ANTLR end "expression"
 14326  
 
 14327  
 
 14328  0
     public static class unaryExpression_return extends TreeRuleReturnScope {
 14329  
         CommonTree tree;
 14330  0
         public Object getTree() { return tree; }
 14331  
     };
 14332  
 
 14333  
 
 14334  
     // $ANTLR start "unaryExpression"
 14335  
     // com\\googlecode\\sparkleg\\SparqlT.g:437:1: unaryExpression : ( ^( UNARY NEGATION primaryExpression ) | ^( UNARY PLUS primaryExpression ) | ^( UNARY MINUS primaryExpression ) | ^( UNARY primaryExpression ) );
 14336  
     public final SparqlT.unaryExpression_return unaryExpression() throws RecognitionException {
 14337  0
         SparqlT.unaryExpression_return retval = new SparqlT.unaryExpression_return();
 14338  0
         retval.start = input.LT(1);
 14339  
 
 14340  
 
 14341  0
         CommonTree root_0 = null;
 14342  
 
 14343  0
         CommonTree _first_0 = null;
 14344  0
         CommonTree _last = null;
 14345  
 
 14346  0
         CommonTree UNARY382=null;
 14347  0
         CommonTree NEGATION383=null;
 14348  0
         CommonTree UNARY385=null;
 14349  0
         CommonTree PLUS386=null;
 14350  0
         CommonTree UNARY388=null;
 14351  0
         CommonTree MINUS389=null;
 14352  0
         CommonTree UNARY391=null;
 14353  0
         SparqlT.primaryExpression_return primaryExpression384 =null;
 14354  
 
 14355  0
         SparqlT.primaryExpression_return primaryExpression387 =null;
 14356  
 
 14357  0
         SparqlT.primaryExpression_return primaryExpression390 =null;
 14358  
 
 14359  0
         SparqlT.primaryExpression_return primaryExpression392 =null;
 14360  
 
 14361  
 
 14362  0
         CommonTree UNARY382_tree=null;
 14363  0
         CommonTree NEGATION383_tree=null;
 14364  0
         CommonTree UNARY385_tree=null;
 14365  0
         CommonTree PLUS386_tree=null;
 14366  0
         CommonTree UNARY388_tree=null;
 14367  0
         CommonTree MINUS389_tree=null;
 14368  0
         CommonTree UNARY391_tree=null;
 14369  
 
 14370  
         try {
 14371  
             // com\\googlecode\\sparkleg\\SparqlT.g:438:5: ( ^( UNARY NEGATION primaryExpression ) | ^( UNARY PLUS primaryExpression ) | ^( UNARY MINUS primaryExpression ) | ^( UNARY primaryExpression ) )
 14372  0
             int alt127=4;
 14373  0
             switch ( input.LA(1) ) {
 14374  
             case UNARY:
 14375  
                 {
 14376  0
                 switch ( input.LA(2) ) {
 14377  
                 case DOWN:
 14378  
                     {
 14379  0
                     switch ( input.LA(3) ) {
 14380  
                     case NEGATION:
 14381  
                         {
 14382  0
                         alt127=1;
 14383  
                         }
 14384  0
                         break;
 14385  
                     case PLUS:
 14386  
                         {
 14387  0
                         alt127=2;
 14388  
                         }
 14389  0
                         break;
 14390  
                     case MINUS:
 14391  
                         {
 14392  0
                         alt127=3;
 14393  
                         }
 14394  0
                         break;
 14395  
                     case ABS:
 14396  
                     case AVG:
 14397  
                     case BNODE:
 14398  
                     case BOUND:
 14399  
                     case BRACKETTED_EXPRESSION:
 14400  
                     case CEIL:
 14401  
                     case COALESCE:
 14402  
                     case CONCAT:
 14403  
                     case CONTAINS:
 14404  
                     case COUNT:
 14405  
                     case DATATYPE:
 14406  
                     case DAY:
 14407  
                     case DECIMAL:
 14408  
                     case DECIMAL_NEGATIVE:
 14409  
                     case DECIMAL_POSITIVE:
 14410  
                     case DOUBLE:
 14411  
                     case DOUBLE_NEGATIVE:
 14412  
                     case DOUBLE_POSITIVE:
 14413  
                     case ENCODE_FOR_URI:
 14414  
                     case EXISTS:
 14415  
                     case FALSE:
 14416  
                     case FLOOR:
 14417  
                     case FUNCTION:
 14418  
                     case GROUP_CONCAT:
 14419  
                     case HOURS:
 14420  
                     case IF:
 14421  
                     case INTEGER:
 14422  
                     case INTEGER_NEGATIVE:
 14423  
                     case INTEGER_POSITIVE:
 14424  
                     case IRI:
 14425  
                     case ISBLANK:
 14426  
                     case ISIRI:
 14427  
                     case ISLITERAL:
 14428  
                     case ISNUMERIC:
 14429  
                     case ISURI:
 14430  
                     case LANG:
 14431  
                     case LANGMATCHES:
 14432  
                     case LCASE:
 14433  
                     case MAX:
 14434  
                     case MD5:
 14435  
                     case MIN:
 14436  
                     case MINUTES:
 14437  
                     case MONTH:
 14438  
                     case NOT_EXISTS:
 14439  
                     case NOW:
 14440  
                     case RAND:
 14441  
                     case REGEX:
 14442  
                     case REPLACE:
 14443  
                     case ROUND:
 14444  
                     case SAMETERM:
 14445  
                     case SAMPLE:
 14446  
                     case SECONDS:
 14447  
                     case SHA1:
 14448  
                     case SHA224:
 14449  
                     case SHA256:
 14450  
                     case SHA384:
 14451  
                     case SHA512:
 14452  
                     case STR:
 14453  
                     case STRAFTER:
 14454  
                     case STRBEFORE:
 14455  
                     case STRDT:
 14456  
                     case STRENDS:
 14457  
                     case STRING_LITERAL1:
 14458  
                     case STRING_LITERAL2:
 14459  
                     case STRING_LITERAL_LONG1:
 14460  
                     case STRING_LITERAL_LONG2:
 14461  
                     case STRLANG:
 14462  
                     case STRLEN:
 14463  
                     case STRSTARTS:
 14464  
                     case SUBSTR:
 14465  
                     case SUM:
 14466  
                     case TIMEZONE:
 14467  
                     case TRUE:
 14468  
                     case TZ:
 14469  
                     case UCASE:
 14470  
                     case URI:
 14471  
                     case VAR1:
 14472  
                     case VAR2:
 14473  
                     case YEAR:
 14474  
                         {
 14475  0
                         alt127=4;
 14476  
                         }
 14477  0
                         break;
 14478  
                     default:
 14479  0
                         NoViableAltException nvae =
 14480  
                             new NoViableAltException("", 127, 2, input);
 14481  
 
 14482  0
                         throw nvae;
 14483  
 
 14484  
                     }
 14485  
 
 14486  
                     }
 14487  0
                     break;
 14488  
                 default:
 14489  0
                     NoViableAltException nvae =
 14490  
                         new NoViableAltException("", 127, 1, input);
 14491  
 
 14492  0
                     throw nvae;
 14493  
 
 14494  
                 }
 14495  
 
 14496  
                 }
 14497  0
                 break;
 14498  
             default:
 14499  0
                 NoViableAltException nvae =
 14500  
                     new NoViableAltException("", 127, 0, input);
 14501  
 
 14502  0
                 throw nvae;
 14503  
 
 14504  
             }
 14505  
 
 14506  0
             switch (alt127) {
 14507  
                 case 1 :
 14508  
                     // com\\googlecode\\sparkleg\\SparqlT.g:438:7: ^( UNARY NEGATION primaryExpression )
 14509  
                     {
 14510  0
                     root_0 = (CommonTree)adaptor.nil();
 14511  
 
 14512  
 
 14513  0
                     _last = (CommonTree)input.LT(1);
 14514  
                     {
 14515  0
                     CommonTree _save_last_1 = _last;
 14516  0
                     CommonTree _first_1 = null;
 14517  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 14518  0
                     _last = (CommonTree)input.LT(1);
 14519  0
                     UNARY382=(CommonTree)match(input,UNARY,FOLLOW_UNARY_in_unaryExpression3006); 
 14520  0
                     UNARY382_tree = (CommonTree)adaptor.dupNode(UNARY382);
 14521  
 
 14522  
 
 14523  0
                     root_1 = (CommonTree)adaptor.becomeRoot(UNARY382_tree, root_1);
 14524  
 
 14525  
 
 14526  0
                     match(input, Token.DOWN, null); 
 14527  0
                     _last = (CommonTree)input.LT(1);
 14528  0
                     NEGATION383=(CommonTree)match(input,NEGATION,FOLLOW_NEGATION_in_unaryExpression3008); 
 14529  0
                     NEGATION383_tree = (CommonTree)adaptor.dupNode(NEGATION383);
 14530  
 
 14531  
 
 14532  0
                     adaptor.addChild(root_1, NEGATION383_tree);
 14533  
 
 14534  
 
 14535  0
                     _last = (CommonTree)input.LT(1);
 14536  0
                     pushFollow(FOLLOW_primaryExpression_in_unaryExpression3010);
 14537  0
                     primaryExpression384=primaryExpression();
 14538  
 
 14539  0
                     state._fsp--;
 14540  
 
 14541  0
                     adaptor.addChild(root_1, primaryExpression384.getTree());
 14542  
 
 14543  
 
 14544  0
                     match(input, Token.UP, null); 
 14545  0
                     adaptor.addChild(root_0, root_1);
 14546  0
                     _last = _save_last_1;
 14547  
                     }
 14548  
 
 14549  
 
 14550  
                     }
 14551  0
                     break;
 14552  
                 case 2 :
 14553  
                     // com\\googlecode\\sparkleg\\SparqlT.g:439:7: ^( UNARY PLUS primaryExpression )
 14554  
                     {
 14555  0
                     root_0 = (CommonTree)adaptor.nil();
 14556  
 
 14557  
 
 14558  0
                     _last = (CommonTree)input.LT(1);
 14559  
                     {
 14560  0
                     CommonTree _save_last_1 = _last;
 14561  0
                     CommonTree _first_1 = null;
 14562  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 14563  0
                     _last = (CommonTree)input.LT(1);
 14564  0
                     UNARY385=(CommonTree)match(input,UNARY,FOLLOW_UNARY_in_unaryExpression3020); 
 14565  0
                     UNARY385_tree = (CommonTree)adaptor.dupNode(UNARY385);
 14566  
 
 14567  
 
 14568  0
                     root_1 = (CommonTree)adaptor.becomeRoot(UNARY385_tree, root_1);
 14569  
 
 14570  
 
 14571  0
                     match(input, Token.DOWN, null); 
 14572  0
                     _last = (CommonTree)input.LT(1);
 14573  0
                     PLUS386=(CommonTree)match(input,PLUS,FOLLOW_PLUS_in_unaryExpression3022); 
 14574  0
                     PLUS386_tree = (CommonTree)adaptor.dupNode(PLUS386);
 14575  
 
 14576  
 
 14577  0
                     adaptor.addChild(root_1, PLUS386_tree);
 14578  
 
 14579  
 
 14580  0
                     _last = (CommonTree)input.LT(1);
 14581  0
                     pushFollow(FOLLOW_primaryExpression_in_unaryExpression3024);
 14582  0
                     primaryExpression387=primaryExpression();
 14583  
 
 14584  0
                     state._fsp--;
 14585  
 
 14586  0
                     adaptor.addChild(root_1, primaryExpression387.getTree());
 14587  
 
 14588  
 
 14589  0
                     match(input, Token.UP, null); 
 14590  0
                     adaptor.addChild(root_0, root_1);
 14591  0
                     _last = _save_last_1;
 14592  
                     }
 14593  
 
 14594  
 
 14595  
                     }
 14596  0
                     break;
 14597  
                 case 3 :
 14598  
                     // com\\googlecode\\sparkleg\\SparqlT.g:440:7: ^( UNARY MINUS primaryExpression )
 14599  
                     {
 14600  0
                     root_0 = (CommonTree)adaptor.nil();
 14601  
 
 14602  
 
 14603  0
                     _last = (CommonTree)input.LT(1);
 14604  
                     {
 14605  0
                     CommonTree _save_last_1 = _last;
 14606  0
                     CommonTree _first_1 = null;
 14607  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 14608  0
                     _last = (CommonTree)input.LT(1);
 14609  0
                     UNARY388=(CommonTree)match(input,UNARY,FOLLOW_UNARY_in_unaryExpression3034); 
 14610  0
                     UNARY388_tree = (CommonTree)adaptor.dupNode(UNARY388);
 14611  
 
 14612  
 
 14613  0
                     root_1 = (CommonTree)adaptor.becomeRoot(UNARY388_tree, root_1);
 14614  
 
 14615  
 
 14616  0
                     match(input, Token.DOWN, null); 
 14617  0
                     _last = (CommonTree)input.LT(1);
 14618  0
                     MINUS389=(CommonTree)match(input,MINUS,FOLLOW_MINUS_in_unaryExpression3036); 
 14619  0
                     MINUS389_tree = (CommonTree)adaptor.dupNode(MINUS389);
 14620  
 
 14621  
 
 14622  0
                     adaptor.addChild(root_1, MINUS389_tree);
 14623  
 
 14624  
 
 14625  0
                     _last = (CommonTree)input.LT(1);
 14626  0
                     pushFollow(FOLLOW_primaryExpression_in_unaryExpression3038);
 14627  0
                     primaryExpression390=primaryExpression();
 14628  
 
 14629  0
                     state._fsp--;
 14630  
 
 14631  0
                     adaptor.addChild(root_1, primaryExpression390.getTree());
 14632  
 
 14633  
 
 14634  0
                     match(input, Token.UP, null); 
 14635  0
                     adaptor.addChild(root_0, root_1);
 14636  0
                     _last = _save_last_1;
 14637  
                     }
 14638  
 
 14639  
 
 14640  
                     }
 14641  0
                     break;
 14642  
                 case 4 :
 14643  
                     // com\\googlecode\\sparkleg\\SparqlT.g:441:7: ^( UNARY primaryExpression )
 14644  
                     {
 14645  0
                     root_0 = (CommonTree)adaptor.nil();
 14646  
 
 14647  
 
 14648  0
                     _last = (CommonTree)input.LT(1);
 14649  
                     {
 14650  0
                     CommonTree _save_last_1 = _last;
 14651  0
                     CommonTree _first_1 = null;
 14652  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 14653  0
                     _last = (CommonTree)input.LT(1);
 14654  0
                     UNARY391=(CommonTree)match(input,UNARY,FOLLOW_UNARY_in_unaryExpression3048); 
 14655  0
                     UNARY391_tree = (CommonTree)adaptor.dupNode(UNARY391);
 14656  
 
 14657  
 
 14658  0
                     root_1 = (CommonTree)adaptor.becomeRoot(UNARY391_tree, root_1);
 14659  
 
 14660  
 
 14661  0
                     match(input, Token.DOWN, null); 
 14662  0
                     _last = (CommonTree)input.LT(1);
 14663  0
                     pushFollow(FOLLOW_primaryExpression_in_unaryExpression3050);
 14664  0
                     primaryExpression392=primaryExpression();
 14665  
 
 14666  0
                     state._fsp--;
 14667  
 
 14668  0
                     adaptor.addChild(root_1, primaryExpression392.getTree());
 14669  
 
 14670  
 
 14671  0
                     match(input, Token.UP, null); 
 14672  0
                     adaptor.addChild(root_0, root_1);
 14673  0
                     _last = _save_last_1;
 14674  
                     }
 14675  
 
 14676  
 
 14677  
                     }
 14678  
                     break;
 14679  
 
 14680  
             }
 14681  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 14682  
 
 14683  
         }
 14684  0
         catch (RecognitionException re) {
 14685  0
             reportError(re);
 14686  0
             recover(input,re);
 14687  
         }
 14688  
 
 14689  0
         finally {
 14690  
                 // do for sure before leaving
 14691  0
         }
 14692  0
         return retval;
 14693  
     }
 14694  
     // $ANTLR end "unaryExpression"
 14695  
 
 14696  
 
 14697  0
     public static class primaryExpression_return extends TreeRuleReturnScope {
 14698  
         CommonTree tree;
 14699  0
         public Object getTree() { return tree; }
 14700  
     };
 14701  
 
 14702  
 
 14703  
     // $ANTLR start "primaryExpression"
 14704  
     // com\\googlecode\\sparkleg\\SparqlT.g:444:1: primaryExpression : ( brackettedExpression | builtInCall | iriRefOrFunction | rdfLiteral | numericLiteral | booleanLiteral | var | aggregate );
 14705  
     public final SparqlT.primaryExpression_return primaryExpression() throws RecognitionException {
 14706  0
         SparqlT.primaryExpression_return retval = new SparqlT.primaryExpression_return();
 14707  0
         retval.start = input.LT(1);
 14708  
 
 14709  
 
 14710  0
         CommonTree root_0 = null;
 14711  
 
 14712  0
         CommonTree _first_0 = null;
 14713  0
         CommonTree _last = null;
 14714  
 
 14715  0
         SparqlT.brackettedExpression_return brackettedExpression393 =null;
 14716  
 
 14717  0
         SparqlT.builtInCall_return builtInCall394 =null;
 14718  
 
 14719  0
         SparqlT.iriRefOrFunction_return iriRefOrFunction395 =null;
 14720  
 
 14721  0
         SparqlT.rdfLiteral_return rdfLiteral396 =null;
 14722  
 
 14723  0
         SparqlT.numericLiteral_return numericLiteral397 =null;
 14724  
 
 14725  0
         SparqlT.booleanLiteral_return booleanLiteral398 =null;
 14726  
 
 14727  0
         SparqlT.var_return var399 =null;
 14728  
 
 14729  0
         SparqlT.aggregate_return aggregate400 =null;
 14730  
 
 14731  
 
 14732  
 
 14733  
         try {
 14734  
             // com\\googlecode\\sparkleg\\SparqlT.g:445:5: ( brackettedExpression | builtInCall | iriRefOrFunction | rdfLiteral | numericLiteral | booleanLiteral | var | aggregate )
 14735  0
             int alt128=8;
 14736  0
             switch ( input.LA(1) ) {
 14737  
             case BRACKETTED_EXPRESSION:
 14738  
                 {
 14739  0
                 alt128=1;
 14740  
                 }
 14741  0
                 break;
 14742  
             case ABS:
 14743  
             case BNODE:
 14744  
             case BOUND:
 14745  
             case CEIL:
 14746  
             case COALESCE:
 14747  
             case CONCAT:
 14748  
             case CONTAINS:
 14749  
             case DATATYPE:
 14750  
             case DAY:
 14751  
             case ENCODE_FOR_URI:
 14752  
             case EXISTS:
 14753  
             case FLOOR:
 14754  
             case HOURS:
 14755  
             case IF:
 14756  
             case IRI:
 14757  
             case ISBLANK:
 14758  
             case ISIRI:
 14759  
             case ISLITERAL:
 14760  
             case ISNUMERIC:
 14761  
             case ISURI:
 14762  
             case LANG:
 14763  
             case LANGMATCHES:
 14764  
             case LCASE:
 14765  
             case MD5:
 14766  
             case MINUTES:
 14767  
             case MONTH:
 14768  
             case NOT_EXISTS:
 14769  
             case NOW:
 14770  
             case RAND:
 14771  
             case REGEX:
 14772  
             case REPLACE:
 14773  
             case ROUND:
 14774  
             case SAMETERM:
 14775  
             case SECONDS:
 14776  
             case SHA1:
 14777  
             case SHA224:
 14778  
             case SHA256:
 14779  
             case SHA384:
 14780  
             case SHA512:
 14781  
             case STR:
 14782  
             case STRAFTER:
 14783  
             case STRBEFORE:
 14784  
             case STRDT:
 14785  
             case STRENDS:
 14786  
             case STRLANG:
 14787  
             case STRLEN:
 14788  
             case STRSTARTS:
 14789  
             case SUBSTR:
 14790  
             case TIMEZONE:
 14791  
             case TZ:
 14792  
             case UCASE:
 14793  
             case URI:
 14794  
             case YEAR:
 14795  
                 {
 14796  0
                 alt128=2;
 14797  
                 }
 14798  0
                 break;
 14799  
             case FUNCTION:
 14800  
                 {
 14801  0
                 alt128=3;
 14802  
                 }
 14803  0
                 break;
 14804  
             case STRING_LITERAL1:
 14805  
             case STRING_LITERAL2:
 14806  
             case STRING_LITERAL_LONG1:
 14807  
             case STRING_LITERAL_LONG2:
 14808  
                 {
 14809  0
                 alt128=4;
 14810  
                 }
 14811  0
                 break;
 14812  
             case DECIMAL:
 14813  
             case DECIMAL_NEGATIVE:
 14814  
             case DECIMAL_POSITIVE:
 14815  
             case DOUBLE:
 14816  
             case DOUBLE_NEGATIVE:
 14817  
             case DOUBLE_POSITIVE:
 14818  
             case INTEGER:
 14819  
             case INTEGER_NEGATIVE:
 14820  
             case INTEGER_POSITIVE:
 14821  
                 {
 14822  0
                 alt128=5;
 14823  
                 }
 14824  0
                 break;
 14825  
             case FALSE:
 14826  
             case TRUE:
 14827  
                 {
 14828  0
                 alt128=6;
 14829  
                 }
 14830  0
                 break;
 14831  
             case VAR1:
 14832  
             case VAR2:
 14833  
                 {
 14834  0
                 alt128=7;
 14835  
                 }
 14836  0
                 break;
 14837  
             case AVG:
 14838  
             case COUNT:
 14839  
             case GROUP_CONCAT:
 14840  
             case MAX:
 14841  
             case MIN:
 14842  
             case SAMPLE:
 14843  
             case SUM:
 14844  
                 {
 14845  0
                 alt128=8;
 14846  
                 }
 14847  0
                 break;
 14848  
             default:
 14849  0
                 NoViableAltException nvae =
 14850  
                     new NoViableAltException("", 128, 0, input);
 14851  
 
 14852  0
                 throw nvae;
 14853  
 
 14854  
             }
 14855  
 
 14856  0
             switch (alt128) {
 14857  
                 case 1 :
 14858  
                     // com\\googlecode\\sparkleg\\SparqlT.g:445:7: brackettedExpression
 14859  
                     {
 14860  0
                     root_0 = (CommonTree)adaptor.nil();
 14861  
 
 14862  
 
 14863  0
                     _last = (CommonTree)input.LT(1);
 14864  0
                     pushFollow(FOLLOW_brackettedExpression_in_primaryExpression3069);
 14865  0
                     brackettedExpression393=brackettedExpression();
 14866  
 
 14867  0
                     state._fsp--;
 14868  
 
 14869  0
                     adaptor.addChild(root_0, brackettedExpression393.getTree());
 14870  
 
 14871  
 
 14872  
                     }
 14873  0
                     break;
 14874  
                 case 2 :
 14875  
                     // com\\googlecode\\sparkleg\\SparqlT.g:445:30: builtInCall
 14876  
                     {
 14877  0
                     root_0 = (CommonTree)adaptor.nil();
 14878  
 
 14879  
 
 14880  0
                     _last = (CommonTree)input.LT(1);
 14881  0
                     pushFollow(FOLLOW_builtInCall_in_primaryExpression3073);
 14882  0
                     builtInCall394=builtInCall();
 14883  
 
 14884  0
                     state._fsp--;
 14885  
 
 14886  0
                     adaptor.addChild(root_0, builtInCall394.getTree());
 14887  
 
 14888  
 
 14889  
                     }
 14890  0
                     break;
 14891  
                 case 3 :
 14892  
                     // com\\googlecode\\sparkleg\\SparqlT.g:445:44: iriRefOrFunction
 14893  
                     {
 14894  0
                     root_0 = (CommonTree)adaptor.nil();
 14895  
 
 14896  
 
 14897  0
                     _last = (CommonTree)input.LT(1);
 14898  0
                     pushFollow(FOLLOW_iriRefOrFunction_in_primaryExpression3077);
 14899  0
                     iriRefOrFunction395=iriRefOrFunction();
 14900  
 
 14901  0
                     state._fsp--;
 14902  
 
 14903  0
                     adaptor.addChild(root_0, iriRefOrFunction395.getTree());
 14904  
 
 14905  
 
 14906  
                     }
 14907  0
                     break;
 14908  
                 case 4 :
 14909  
                     // com\\googlecode\\sparkleg\\SparqlT.g:445:63: rdfLiteral
 14910  
                     {
 14911  0
                     root_0 = (CommonTree)adaptor.nil();
 14912  
 
 14913  
 
 14914  0
                     _last = (CommonTree)input.LT(1);
 14915  0
                     pushFollow(FOLLOW_rdfLiteral_in_primaryExpression3081);
 14916  0
                     rdfLiteral396=rdfLiteral();
 14917  
 
 14918  0
                     state._fsp--;
 14919  
 
 14920  0
                     adaptor.addChild(root_0, rdfLiteral396.getTree());
 14921  
 
 14922  
 
 14923  
                     }
 14924  0
                     break;
 14925  
                 case 5 :
 14926  
                     // com\\googlecode\\sparkleg\\SparqlT.g:445:76: numericLiteral
 14927  
                     {
 14928  0
                     root_0 = (CommonTree)adaptor.nil();
 14929  
 
 14930  
 
 14931  0
                     _last = (CommonTree)input.LT(1);
 14932  0
                     pushFollow(FOLLOW_numericLiteral_in_primaryExpression3085);
 14933  0
                     numericLiteral397=numericLiteral();
 14934  
 
 14935  0
                     state._fsp--;
 14936  
 
 14937  0
                     adaptor.addChild(root_0, numericLiteral397.getTree());
 14938  
 
 14939  
 
 14940  
                     }
 14941  0
                     break;
 14942  
                 case 6 :
 14943  
                     // com\\googlecode\\sparkleg\\SparqlT.g:445:93: booleanLiteral
 14944  
                     {
 14945  0
                     root_0 = (CommonTree)adaptor.nil();
 14946  
 
 14947  
 
 14948  0
                     _last = (CommonTree)input.LT(1);
 14949  0
                     pushFollow(FOLLOW_booleanLiteral_in_primaryExpression3089);
 14950  0
                     booleanLiteral398=booleanLiteral();
 14951  
 
 14952  0
                     state._fsp--;
 14953  
 
 14954  0
                     adaptor.addChild(root_0, booleanLiteral398.getTree());
 14955  
 
 14956  
 
 14957  
                     }
 14958  0
                     break;
 14959  
                 case 7 :
 14960  
                     // com\\googlecode\\sparkleg\\SparqlT.g:445:110: var
 14961  
                     {
 14962  0
                     root_0 = (CommonTree)adaptor.nil();
 14963  
 
 14964  
 
 14965  0
                     _last = (CommonTree)input.LT(1);
 14966  0
                     pushFollow(FOLLOW_var_in_primaryExpression3093);
 14967  0
                     var399=var();
 14968  
 
 14969  0
                     state._fsp--;
 14970  
 
 14971  0
                     adaptor.addChild(root_0, var399.getTree());
 14972  
 
 14973  
 
 14974  
                     }
 14975  0
                     break;
 14976  
                 case 8 :
 14977  
                     // com\\googlecode\\sparkleg\\SparqlT.g:445:116: aggregate
 14978  
                     {
 14979  0
                     root_0 = (CommonTree)adaptor.nil();
 14980  
 
 14981  
 
 14982  0
                     _last = (CommonTree)input.LT(1);
 14983  0
                     pushFollow(FOLLOW_aggregate_in_primaryExpression3097);
 14984  0
                     aggregate400=aggregate();
 14985  
 
 14986  0
                     state._fsp--;
 14987  
 
 14988  0
                     adaptor.addChild(root_0, aggregate400.getTree());
 14989  
 
 14990  
 
 14991  
                     }
 14992  
                     break;
 14993  
 
 14994  
             }
 14995  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 14996  
 
 14997  
         }
 14998  0
         catch (RecognitionException re) {
 14999  0
             reportError(re);
 15000  0
             recover(input,re);
 15001  
         }
 15002  
 
 15003  0
         finally {
 15004  
                 // do for sure before leaving
 15005  0
         }
 15006  0
         return retval;
 15007  
     }
 15008  
     // $ANTLR end "primaryExpression"
 15009  
 
 15010  
 
 15011  0
     public static class brackettedExpression_return extends TreeRuleReturnScope {
 15012  
         CommonTree tree;
 15013  0
         public Object getTree() { return tree; }
 15014  
     };
 15015  
 
 15016  
 
 15017  
     // $ANTLR start "brackettedExpression"
 15018  
     // com\\googlecode\\sparkleg\\SparqlT.g:448:1: brackettedExpression : ^( BRACKETTED_EXPRESSION e= expression ) ;
 15019  
     public final SparqlT.brackettedExpression_return brackettedExpression() throws RecognitionException {
 15020  0
         SparqlT.brackettedExpression_return retval = new SparqlT.brackettedExpression_return();
 15021  0
         retval.start = input.LT(1);
 15022  
 
 15023  
 
 15024  0
         CommonTree root_0 = null;
 15025  
 
 15026  0
         CommonTree _first_0 = null;
 15027  0
         CommonTree _last = null;
 15028  
 
 15029  0
         CommonTree BRACKETTED_EXPRESSION401=null;
 15030  0
         SparqlT.expression_return e =null;
 15031  
 
 15032  
 
 15033  0
         CommonTree BRACKETTED_EXPRESSION401_tree=null;
 15034  
 
 15035  
         try {
 15036  
             // com\\googlecode\\sparkleg\\SparqlT.g:449:5: ( ^( BRACKETTED_EXPRESSION e= expression ) )
 15037  
             // com\\googlecode\\sparkleg\\SparqlT.g:449:7: ^( BRACKETTED_EXPRESSION e= expression )
 15038  
             {
 15039  0
             root_0 = (CommonTree)adaptor.nil();
 15040  
 
 15041  
 
 15042  0
             _last = (CommonTree)input.LT(1);
 15043  
             {
 15044  0
             CommonTree _save_last_1 = _last;
 15045  0
             CommonTree _first_1 = null;
 15046  0
             CommonTree root_1 = (CommonTree)adaptor.nil();
 15047  0
             _last = (CommonTree)input.LT(1);
 15048  0
             BRACKETTED_EXPRESSION401=(CommonTree)match(input,BRACKETTED_EXPRESSION,FOLLOW_BRACKETTED_EXPRESSION_in_brackettedExpression3115); 
 15049  0
             BRACKETTED_EXPRESSION401_tree = (CommonTree)adaptor.dupNode(BRACKETTED_EXPRESSION401);
 15050  
 
 15051  
 
 15052  0
             root_1 = (CommonTree)adaptor.becomeRoot(BRACKETTED_EXPRESSION401_tree, root_1);
 15053  
 
 15054  
 
 15055  0
             match(input, Token.DOWN, null); 
 15056  0
             _last = (CommonTree)input.LT(1);
 15057  0
             pushFollow(FOLLOW_expression_in_brackettedExpression3119);
 15058  0
             e=expression();
 15059  
 
 15060  0
             state._fsp--;
 15061  
 
 15062  0
             adaptor.addChild(root_1, e.getTree());
 15063  
 
 15064  
 
 15065  0
             match(input, Token.UP, null); 
 15066  0
             adaptor.addChild(root_0, root_1);
 15067  0
             _last = _save_last_1;
 15068  
             }
 15069  
 
 15070  
 
 15071  
             }
 15072  
 
 15073  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 15074  
 
 15075  
         }
 15076  0
         catch (RecognitionException re) {
 15077  0
             reportError(re);
 15078  0
             recover(input,re);
 15079  
         }
 15080  
 
 15081  0
         finally {
 15082  
                 // do for sure before leaving
 15083  0
         }
 15084  0
         return retval;
 15085  
     }
 15086  
     // $ANTLR end "brackettedExpression"
 15087  
 
 15088  
 
 15089  0
     public static class builtInCall_return extends TreeRuleReturnScope {
 15090  
         CommonTree tree;
 15091  0
         public Object getTree() { return tree; }
 15092  
     };
 15093  
 
 15094  
 
 15095  
     // $ANTLR start "builtInCall"
 15096  
     // com\\googlecode\\sparkleg\\SparqlT.g:452:1: builtInCall : ( ^( STR expression ) | ^( LANG expression ) | ^( LANGMATCHES ( expression )+ ) | ^( DATATYPE expression ) | ^( BOUND var ) | ^( IRI expression ) | ^( URI expression ) | ^( BNODE expression ) | BNODE | RAND | ^( ABS expression ) | ^( CEIL expression ) | ^( FLOOR expression ) | ^( ROUND expression ) | ^( CONCAT expressionList ) | subStringExpression | ^( STRLEN expression ) | ^( UCASE expression ) | ^( LCASE expression ) | ^( ENCODE_FOR_URI expression ) | ^( CONTAINS expression expression ) | ^( STRSTARTS expression expression ) | ^( STRENDS expression expression ) | ^( STRBEFORE expression expression ) | ^( STRAFTER expression expression ) | ^( REPLACE expression expression expression ) | ^( YEAR expression ) | ^( MONTH expression ) | ^( DAY expression ) | ^( HOURS expression ) | ^( MINUTES expression ) | ^( SECONDS expression ) | ^( TIMEZONE expression ) | ^( TZ expression ) | NOW | ^( MD5 expression ) | ^( SHA1 expression ) | ^( SHA224 expression ) | ^( SHA256 expression ) | ^( SHA384 expression ) | ^( SHA512 expression ) | ^( COALESCE expressionList ) | ^( IF expression expression expression ) | ^( STRLANG expression expression ) | ^( STRDT expression expression ) | ^( SAMETERM expression expression ) | ^( ISIRI expression ) | ^( ISURI expression ) | ^( ISBLANK expression ) | ^( ISLITERAL expression ) | ^( ISNUMERIC expression ) | regexExpression | existsFunction | notExistsFunction );
 15097  
     public final SparqlT.builtInCall_return builtInCall() throws RecognitionException {
 15098  0
         SparqlT.builtInCall_return retval = new SparqlT.builtInCall_return();
 15099  0
         retval.start = input.LT(1);
 15100  
 
 15101  
 
 15102  0
         CommonTree root_0 = null;
 15103  
 
 15104  0
         CommonTree _first_0 = null;
 15105  0
         CommonTree _last = null;
 15106  
 
 15107  0
         CommonTree STR402=null;
 15108  0
         CommonTree LANG404=null;
 15109  0
         CommonTree LANGMATCHES406=null;
 15110  0
         CommonTree DATATYPE408=null;
 15111  0
         CommonTree BOUND410=null;
 15112  0
         CommonTree IRI412=null;
 15113  0
         CommonTree URI414=null;
 15114  0
         CommonTree BNODE416=null;
 15115  0
         CommonTree BNODE418=null;
 15116  0
         CommonTree RAND419=null;
 15117  0
         CommonTree ABS420=null;
 15118  0
         CommonTree CEIL422=null;
 15119  0
         CommonTree FLOOR424=null;
 15120  0
         CommonTree ROUND426=null;
 15121  0
         CommonTree CONCAT428=null;
 15122  0
         CommonTree STRLEN431=null;
 15123  0
         CommonTree UCASE433=null;
 15124  0
         CommonTree LCASE435=null;
 15125  0
         CommonTree ENCODE_FOR_URI437=null;
 15126  0
         CommonTree CONTAINS439=null;
 15127  0
         CommonTree STRSTARTS442=null;
 15128  0
         CommonTree STRENDS445=null;
 15129  0
         CommonTree STRBEFORE448=null;
 15130  0
         CommonTree STRAFTER451=null;
 15131  0
         CommonTree REPLACE454=null;
 15132  0
         CommonTree YEAR458=null;
 15133  0
         CommonTree MONTH460=null;
 15134  0
         CommonTree DAY462=null;
 15135  0
         CommonTree HOURS464=null;
 15136  0
         CommonTree MINUTES466=null;
 15137  0
         CommonTree SECONDS468=null;
 15138  0
         CommonTree TIMEZONE470=null;
 15139  0
         CommonTree TZ472=null;
 15140  0
         CommonTree NOW474=null;
 15141  0
         CommonTree MD5475=null;
 15142  0
         CommonTree SHA1477=null;
 15143  0
         CommonTree SHA224479=null;
 15144  0
         CommonTree SHA256481=null;
 15145  0
         CommonTree SHA384483=null;
 15146  0
         CommonTree SHA512485=null;
 15147  0
         CommonTree COALESCE487=null;
 15148  0
         CommonTree IF489=null;
 15149  0
         CommonTree STRLANG493=null;
 15150  0
         CommonTree STRDT496=null;
 15151  0
         CommonTree SAMETERM499=null;
 15152  0
         CommonTree ISIRI502=null;
 15153  0
         CommonTree ISURI504=null;
 15154  0
         CommonTree ISBLANK506=null;
 15155  0
         CommonTree ISLITERAL508=null;
 15156  0
         CommonTree ISNUMERIC510=null;
 15157  0
         SparqlT.expression_return expression403 =null;
 15158  
 
 15159  0
         SparqlT.expression_return expression405 =null;
 15160  
 
 15161  0
         SparqlT.expression_return expression407 =null;
 15162  
 
 15163  0
         SparqlT.expression_return expression409 =null;
 15164  
 
 15165  0
         SparqlT.var_return var411 =null;
 15166  
 
 15167  0
         SparqlT.expression_return expression413 =null;
 15168  
 
 15169  0
         SparqlT.expression_return expression415 =null;
 15170  
 
 15171  0
         SparqlT.expression_return expression417 =null;
 15172  
 
 15173  0
         SparqlT.expression_return expression421 =null;
 15174  
 
 15175  0
         SparqlT.expression_return expression423 =null;
 15176  
 
 15177  0
         SparqlT.expression_return expression425 =null;
 15178  
 
 15179  0
         SparqlT.expression_return expression427 =null;
 15180  
 
 15181  0
         SparqlT.expressionList_return expressionList429 =null;
 15182  
 
 15183  0
         SparqlT.subStringExpression_return subStringExpression430 =null;
 15184  
 
 15185  0
         SparqlT.expression_return expression432 =null;
 15186  
 
 15187  0
         SparqlT.expression_return expression434 =null;
 15188  
 
 15189  0
         SparqlT.expression_return expression436 =null;
 15190  
 
 15191  0
         SparqlT.expression_return expression438 =null;
 15192  
 
 15193  0
         SparqlT.expression_return expression440 =null;
 15194  
 
 15195  0
         SparqlT.expression_return expression441 =null;
 15196  
 
 15197  0
         SparqlT.expression_return expression443 =null;
 15198  
 
 15199  0
         SparqlT.expression_return expression444 =null;
 15200  
 
 15201  0
         SparqlT.expression_return expression446 =null;
 15202  
 
 15203  0
         SparqlT.expression_return expression447 =null;
 15204  
 
 15205  0
         SparqlT.expression_return expression449 =null;
 15206  
 
 15207  0
         SparqlT.expression_return expression450 =null;
 15208  
 
 15209  0
         SparqlT.expression_return expression452 =null;
 15210  
 
 15211  0
         SparqlT.expression_return expression453 =null;
 15212  
 
 15213  0
         SparqlT.expression_return expression455 =null;
 15214  
 
 15215  0
         SparqlT.expression_return expression456 =null;
 15216  
 
 15217  0
         SparqlT.expression_return expression457 =null;
 15218  
 
 15219  0
         SparqlT.expression_return expression459 =null;
 15220  
 
 15221  0
         SparqlT.expression_return expression461 =null;
 15222  
 
 15223  0
         SparqlT.expression_return expression463 =null;
 15224  
 
 15225  0
         SparqlT.expression_return expression465 =null;
 15226  
 
 15227  0
         SparqlT.expression_return expression467 =null;
 15228  
 
 15229  0
         SparqlT.expression_return expression469 =null;
 15230  
 
 15231  0
         SparqlT.expression_return expression471 =null;
 15232  
 
 15233  0
         SparqlT.expression_return expression473 =null;
 15234  
 
 15235  0
         SparqlT.expression_return expression476 =null;
 15236  
 
 15237  0
         SparqlT.expression_return expression478 =null;
 15238  
 
 15239  0
         SparqlT.expression_return expression480 =null;
 15240  
 
 15241  0
         SparqlT.expression_return expression482 =null;
 15242  
 
 15243  0
         SparqlT.expression_return expression484 =null;
 15244  
 
 15245  0
         SparqlT.expression_return expression486 =null;
 15246  
 
 15247  0
         SparqlT.expressionList_return expressionList488 =null;
 15248  
 
 15249  0
         SparqlT.expression_return expression490 =null;
 15250  
 
 15251  0
         SparqlT.expression_return expression491 =null;
 15252  
 
 15253  0
         SparqlT.expression_return expression492 =null;
 15254  
 
 15255  0
         SparqlT.expression_return expression494 =null;
 15256  
 
 15257  0
         SparqlT.expression_return expression495 =null;
 15258  
 
 15259  0
         SparqlT.expression_return expression497 =null;
 15260  
 
 15261  0
         SparqlT.expression_return expression498 =null;
 15262  
 
 15263  0
         SparqlT.expression_return expression500 =null;
 15264  
 
 15265  0
         SparqlT.expression_return expression501 =null;
 15266  
 
 15267  0
         SparqlT.expression_return expression503 =null;
 15268  
 
 15269  0
         SparqlT.expression_return expression505 =null;
 15270  
 
 15271  0
         SparqlT.expression_return expression507 =null;
 15272  
 
 15273  0
         SparqlT.expression_return expression509 =null;
 15274  
 
 15275  0
         SparqlT.expression_return expression511 =null;
 15276  
 
 15277  0
         SparqlT.regexExpression_return regexExpression512 =null;
 15278  
 
 15279  0
         SparqlT.existsFunction_return existsFunction513 =null;
 15280  
 
 15281  0
         SparqlT.notExistsFunction_return notExistsFunction514 =null;
 15282  
 
 15283  
 
 15284  0
         CommonTree STR402_tree=null;
 15285  0
         CommonTree LANG404_tree=null;
 15286  0
         CommonTree LANGMATCHES406_tree=null;
 15287  0
         CommonTree DATATYPE408_tree=null;
 15288  0
         CommonTree BOUND410_tree=null;
 15289  0
         CommonTree IRI412_tree=null;
 15290  0
         CommonTree URI414_tree=null;
 15291  0
         CommonTree BNODE416_tree=null;
 15292  0
         CommonTree BNODE418_tree=null;
 15293  0
         CommonTree RAND419_tree=null;
 15294  0
         CommonTree ABS420_tree=null;
 15295  0
         CommonTree CEIL422_tree=null;
 15296  0
         CommonTree FLOOR424_tree=null;
 15297  0
         CommonTree ROUND426_tree=null;
 15298  0
         CommonTree CONCAT428_tree=null;
 15299  0
         CommonTree STRLEN431_tree=null;
 15300  0
         CommonTree UCASE433_tree=null;
 15301  0
         CommonTree LCASE435_tree=null;
 15302  0
         CommonTree ENCODE_FOR_URI437_tree=null;
 15303  0
         CommonTree CONTAINS439_tree=null;
 15304  0
         CommonTree STRSTARTS442_tree=null;
 15305  0
         CommonTree STRENDS445_tree=null;
 15306  0
         CommonTree STRBEFORE448_tree=null;
 15307  0
         CommonTree STRAFTER451_tree=null;
 15308  0
         CommonTree REPLACE454_tree=null;
 15309  0
         CommonTree YEAR458_tree=null;
 15310  0
         CommonTree MONTH460_tree=null;
 15311  0
         CommonTree DAY462_tree=null;
 15312  0
         CommonTree HOURS464_tree=null;
 15313  0
         CommonTree MINUTES466_tree=null;
 15314  0
         CommonTree SECONDS468_tree=null;
 15315  0
         CommonTree TIMEZONE470_tree=null;
 15316  0
         CommonTree TZ472_tree=null;
 15317  0
         CommonTree NOW474_tree=null;
 15318  0
         CommonTree MD5475_tree=null;
 15319  0
         CommonTree SHA1477_tree=null;
 15320  0
         CommonTree SHA224479_tree=null;
 15321  0
         CommonTree SHA256481_tree=null;
 15322  0
         CommonTree SHA384483_tree=null;
 15323  0
         CommonTree SHA512485_tree=null;
 15324  0
         CommonTree COALESCE487_tree=null;
 15325  0
         CommonTree IF489_tree=null;
 15326  0
         CommonTree STRLANG493_tree=null;
 15327  0
         CommonTree STRDT496_tree=null;
 15328  0
         CommonTree SAMETERM499_tree=null;
 15329  0
         CommonTree ISIRI502_tree=null;
 15330  0
         CommonTree ISURI504_tree=null;
 15331  0
         CommonTree ISBLANK506_tree=null;
 15332  0
         CommonTree ISLITERAL508_tree=null;
 15333  0
         CommonTree ISNUMERIC510_tree=null;
 15334  
 
 15335  
         try {
 15336  
             // com\\googlecode\\sparkleg\\SparqlT.g:453:5: ( ^( STR expression ) | ^( LANG expression ) | ^( LANGMATCHES ( expression )+ ) | ^( DATATYPE expression ) | ^( BOUND var ) | ^( IRI expression ) | ^( URI expression ) | ^( BNODE expression ) | BNODE | RAND | ^( ABS expression ) | ^( CEIL expression ) | ^( FLOOR expression ) | ^( ROUND expression ) | ^( CONCAT expressionList ) | subStringExpression | ^( STRLEN expression ) | ^( UCASE expression ) | ^( LCASE expression ) | ^( ENCODE_FOR_URI expression ) | ^( CONTAINS expression expression ) | ^( STRSTARTS expression expression ) | ^( STRENDS expression expression ) | ^( STRBEFORE expression expression ) | ^( STRAFTER expression expression ) | ^( REPLACE expression expression expression ) | ^( YEAR expression ) | ^( MONTH expression ) | ^( DAY expression ) | ^( HOURS expression ) | ^( MINUTES expression ) | ^( SECONDS expression ) | ^( TIMEZONE expression ) | ^( TZ expression ) | NOW | ^( MD5 expression ) | ^( SHA1 expression ) | ^( SHA224 expression ) | ^( SHA256 expression ) | ^( SHA384 expression ) | ^( SHA512 expression ) | ^( COALESCE expressionList ) | ^( IF expression expression expression ) | ^( STRLANG expression expression ) | ^( STRDT expression expression ) | ^( SAMETERM expression expression ) | ^( ISIRI expression ) | ^( ISURI expression ) | ^( ISBLANK expression ) | ^( ISLITERAL expression ) | ^( ISNUMERIC expression ) | regexExpression | existsFunction | notExistsFunction )
 15337  0
             int alt130=54;
 15338  0
             switch ( input.LA(1) ) {
 15339  
             case STR:
 15340  
                 {
 15341  0
                 alt130=1;
 15342  
                 }
 15343  0
                 break;
 15344  
             case LANG:
 15345  
                 {
 15346  0
                 alt130=2;
 15347  
                 }
 15348  0
                 break;
 15349  
             case LANGMATCHES:
 15350  
                 {
 15351  0
                 alt130=3;
 15352  
                 }
 15353  0
                 break;
 15354  
             case DATATYPE:
 15355  
                 {
 15356  0
                 alt130=4;
 15357  
                 }
 15358  0
                 break;
 15359  
             case BOUND:
 15360  
                 {
 15361  0
                 alt130=5;
 15362  
                 }
 15363  0
                 break;
 15364  
             case IRI:
 15365  
                 {
 15366  0
                 alt130=6;
 15367  
                 }
 15368  0
                 break;
 15369  
             case URI:
 15370  
                 {
 15371  0
                 alt130=7;
 15372  
                 }
 15373  0
                 break;
 15374  
             case BNODE:
 15375  
                 {
 15376  0
                 switch ( input.LA(2) ) {
 15377  
                 case DOWN:
 15378  
                     {
 15379  0
                     alt130=8;
 15380  
                     }
 15381  0
                     break;
 15382  
                 case UP:
 15383  
                 case ABS:
 15384  
                 case AND:
 15385  
                 case ASTERISK:
 15386  
                 case BNODE:
 15387  
                 case BOUND:
 15388  
                 case CEIL:
 15389  
                 case COALESCE:
 15390  
                 case CONCAT:
 15391  
                 case CONTAINS:
 15392  
                 case DATATYPE:
 15393  
                 case DAY:
 15394  
                 case DECIMAL_NEGATIVE:
 15395  
                 case DECIMAL_POSITIVE:
 15396  
                 case DIVIDE:
 15397  
                 case DOUBLE_NEGATIVE:
 15398  
                 case DOUBLE_POSITIVE:
 15399  
                 case ENCODE_FOR_URI:
 15400  
                 case EQUAL:
 15401  
                 case EXISTS:
 15402  
                 case FLOOR:
 15403  
                 case FUNCTION:
 15404  
                 case GREATER:
 15405  
                 case GREATER_EQUAL:
 15406  
                 case HOURS:
 15407  
                 case IF:
 15408  
                 case IN:
 15409  
                 case INTEGER_NEGATIVE:
 15410  
                 case INTEGER_POSITIVE:
 15411  
                 case IRI:
 15412  
                 case ISBLANK:
 15413  
                 case ISIRI:
 15414  
                 case ISLITERAL:
 15415  
                 case ISNUMERIC:
 15416  
                 case ISURI:
 15417  
                 case LANG:
 15418  
                 case LANGMATCHES:
 15419  
                 case LCASE:
 15420  
                 case LESS:
 15421  
                 case LESS_EQUAL:
 15422  
                 case MD5:
 15423  
                 case MINUS:
 15424  
                 case MINUTES:
 15425  
                 case MONTH:
 15426  
                 case NOT:
 15427  
                 case NOT_EQUAL:
 15428  
                 case NOT_EXISTS:
 15429  
                 case NOW:
 15430  
                 case OR:
 15431  
                 case PLUS:
 15432  
                 case RAND:
 15433  
                 case REGEX:
 15434  
                 case REPLACE:
 15435  
                 case ROUND:
 15436  
                 case SAMETERM:
 15437  
                 case SECONDS:
 15438  
                 case SHA1:
 15439  
                 case SHA224:
 15440  
                 case SHA256:
 15441  
                 case SHA384:
 15442  
                 case SHA512:
 15443  
                 case STR:
 15444  
                 case STRAFTER:
 15445  
                 case STRBEFORE:
 15446  
                 case STRDT:
 15447  
                 case STRENDS:
 15448  
                 case STRLANG:
 15449  
                 case STRLEN:
 15450  
                 case STRSTARTS:
 15451  
                 case SUBSTR:
 15452  
                 case TIMEZONE:
 15453  
                 case TZ:
 15454  
                 case UCASE:
 15455  
                 case UNARY:
 15456  
                 case URI:
 15457  
                 case YEAR:
 15458  
                     {
 15459  0
                     alt130=9;
 15460  
                     }
 15461  0
                     break;
 15462  
                 default:
 15463  0
                     NoViableAltException nvae =
 15464  
                         new NoViableAltException("", 130, 8, input);
 15465  
 
 15466  0
                     throw nvae;
 15467  
 
 15468  
                 }
 15469  
 
 15470  
                 }
 15471  0
                 break;
 15472  
             case RAND:
 15473  
                 {
 15474  0
                 alt130=10;
 15475  
                 }
 15476  0
                 break;
 15477  
             case ABS:
 15478  
                 {
 15479  0
                 alt130=11;
 15480  
                 }
 15481  0
                 break;
 15482  
             case CEIL:
 15483  
                 {
 15484  0
                 alt130=12;
 15485  
                 }
 15486  0
                 break;
 15487  
             case FLOOR:
 15488  
                 {
 15489  0
                 alt130=13;
 15490  
                 }
 15491  0
                 break;
 15492  
             case ROUND:
 15493  
                 {
 15494  0
                 alt130=14;
 15495  
                 }
 15496  0
                 break;
 15497  
             case CONCAT:
 15498  
                 {
 15499  0
                 alt130=15;
 15500  
                 }
 15501  0
                 break;
 15502  
             case SUBSTR:
 15503  
                 {
 15504  0
                 alt130=16;
 15505  
                 }
 15506  0
                 break;
 15507  
             case STRLEN:
 15508  
                 {
 15509  0
                 alt130=17;
 15510  
                 }
 15511  0
                 break;
 15512  
             case UCASE:
 15513  
                 {
 15514  0
                 alt130=18;
 15515  
                 }
 15516  0
                 break;
 15517  
             case LCASE:
 15518  
                 {
 15519  0
                 alt130=19;
 15520  
                 }
 15521  0
                 break;
 15522  
             case ENCODE_FOR_URI:
 15523  
                 {
 15524  0
                 alt130=20;
 15525  
                 }
 15526  0
                 break;
 15527  
             case CONTAINS:
 15528  
                 {
 15529  0
                 alt130=21;
 15530  
                 }
 15531  0
                 break;
 15532  
             case STRSTARTS:
 15533  
                 {
 15534  0
                 alt130=22;
 15535  
                 }
 15536  0
                 break;
 15537  
             case STRENDS:
 15538  
                 {
 15539  0
                 alt130=23;
 15540  
                 }
 15541  0
                 break;
 15542  
             case STRBEFORE:
 15543  
                 {
 15544  0
                 alt130=24;
 15545  
                 }
 15546  0
                 break;
 15547  
             case STRAFTER:
 15548  
                 {
 15549  0
                 alt130=25;
 15550  
                 }
 15551  0
                 break;
 15552  
             case REPLACE:
 15553  
                 {
 15554  0
                 alt130=26;
 15555  
                 }
 15556  0
                 break;
 15557  
             case YEAR:
 15558  
                 {
 15559  0
                 alt130=27;
 15560  
                 }
 15561  0
                 break;
 15562  
             case MONTH:
 15563  
                 {
 15564  0
                 alt130=28;
 15565  
                 }
 15566  0
                 break;
 15567  
             case DAY:
 15568  
                 {
 15569  0
                 alt130=29;
 15570  
                 }
 15571  0
                 break;
 15572  
             case HOURS:
 15573  
                 {
 15574  0
                 alt130=30;
 15575  
                 }
 15576  0
                 break;
 15577  
             case MINUTES:
 15578  
                 {
 15579  0
                 alt130=31;
 15580  
                 }
 15581  0
                 break;
 15582  
             case SECONDS:
 15583  
                 {
 15584  0
                 alt130=32;
 15585  
                 }
 15586  0
                 break;
 15587  
             case TIMEZONE:
 15588  
                 {
 15589  0
                 alt130=33;
 15590  
                 }
 15591  0
                 break;
 15592  
             case TZ:
 15593  
                 {
 15594  0
                 alt130=34;
 15595  
                 }
 15596  0
                 break;
 15597  
             case NOW:
 15598  
                 {
 15599  0
                 alt130=35;
 15600  
                 }
 15601  0
                 break;
 15602  
             case MD5:
 15603  
                 {
 15604  0
                 alt130=36;
 15605  
                 }
 15606  0
                 break;
 15607  
             case SHA1:
 15608  
                 {
 15609  0
                 alt130=37;
 15610  
                 }
 15611  0
                 break;
 15612  
             case SHA224:
 15613  
                 {
 15614  0
                 alt130=38;
 15615  
                 }
 15616  0
                 break;
 15617  
             case SHA256:
 15618  
                 {
 15619  0
                 alt130=39;
 15620  
                 }
 15621  0
                 break;
 15622  
             case SHA384:
 15623  
                 {
 15624  0
                 alt130=40;
 15625  
                 }
 15626  0
                 break;
 15627  
             case SHA512:
 15628  
                 {
 15629  0
                 alt130=41;
 15630  
                 }
 15631  0
                 break;
 15632  
             case COALESCE:
 15633  
                 {
 15634  0
                 alt130=42;
 15635  
                 }
 15636  0
                 break;
 15637  
             case IF:
 15638  
                 {
 15639  0
                 alt130=43;
 15640  
                 }
 15641  0
                 break;
 15642  
             case STRLANG:
 15643  
                 {
 15644  0
                 alt130=44;
 15645  
                 }
 15646  0
                 break;
 15647  
             case STRDT:
 15648  
                 {
 15649  0
                 alt130=45;
 15650  
                 }
 15651  0
                 break;
 15652  
             case SAMETERM:
 15653  
                 {
 15654  0
                 alt130=46;
 15655  
                 }
 15656  0
                 break;
 15657  
             case ISIRI:
 15658  
                 {
 15659  0
                 alt130=47;
 15660  
                 }
 15661  0
                 break;
 15662  
             case ISURI:
 15663  
                 {
 15664  0
                 alt130=48;
 15665  
                 }
 15666  0
                 break;
 15667  
             case ISBLANK:
 15668  
                 {
 15669  0
                 alt130=49;
 15670  
                 }
 15671  0
                 break;
 15672  
             case ISLITERAL:
 15673  
                 {
 15674  0
                 alt130=50;
 15675  
                 }
 15676  0
                 break;
 15677  
             case ISNUMERIC:
 15678  
                 {
 15679  0
                 alt130=51;
 15680  
                 }
 15681  0
                 break;
 15682  
             case REGEX:
 15683  
                 {
 15684  0
                 alt130=52;
 15685  
                 }
 15686  0
                 break;
 15687  
             case EXISTS:
 15688  
                 {
 15689  0
                 alt130=53;
 15690  
                 }
 15691  0
                 break;
 15692  
             case NOT_EXISTS:
 15693  
                 {
 15694  0
                 alt130=54;
 15695  
                 }
 15696  0
                 break;
 15697  
             default:
 15698  0
                 NoViableAltException nvae =
 15699  
                     new NoViableAltException("", 130, 0, input);
 15700  
 
 15701  0
                 throw nvae;
 15702  
 
 15703  
             }
 15704  
 
 15705  0
             switch (alt130) {
 15706  
                 case 1 :
 15707  
                     // com\\googlecode\\sparkleg\\SparqlT.g:453:7: ^( STR expression )
 15708  
                     {
 15709  0
                     root_0 = (CommonTree)adaptor.nil();
 15710  
 
 15711  
 
 15712  0
                     _last = (CommonTree)input.LT(1);
 15713  
                     {
 15714  0
                     CommonTree _save_last_1 = _last;
 15715  0
                     CommonTree _first_1 = null;
 15716  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 15717  0
                     _last = (CommonTree)input.LT(1);
 15718  0
                     STR402=(CommonTree)match(input,STR,FOLLOW_STR_in_builtInCall3138); 
 15719  0
                     STR402_tree = (CommonTree)adaptor.dupNode(STR402);
 15720  
 
 15721  
 
 15722  0
                     root_1 = (CommonTree)adaptor.becomeRoot(STR402_tree, root_1);
 15723  
 
 15724  
 
 15725  0
                     match(input, Token.DOWN, null); 
 15726  0
                     _last = (CommonTree)input.LT(1);
 15727  0
                     pushFollow(FOLLOW_expression_in_builtInCall3140);
 15728  0
                     expression403=expression();
 15729  
 
 15730  0
                     state._fsp--;
 15731  
 
 15732  0
                     adaptor.addChild(root_1, expression403.getTree());
 15733  
 
 15734  
 
 15735  0
                     match(input, Token.UP, null); 
 15736  0
                     adaptor.addChild(root_0, root_1);
 15737  0
                     _last = _save_last_1;
 15738  
                     }
 15739  
 
 15740  
 
 15741  
                     }
 15742  0
                     break;
 15743  
                 case 2 :
 15744  
                     // com\\googlecode\\sparkleg\\SparqlT.g:454:7: ^( LANG expression )
 15745  
                     {
 15746  0
                     root_0 = (CommonTree)adaptor.nil();
 15747  
 
 15748  
 
 15749  0
                     _last = (CommonTree)input.LT(1);
 15750  
                     {
 15751  0
                     CommonTree _save_last_1 = _last;
 15752  0
                     CommonTree _first_1 = null;
 15753  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 15754  0
                     _last = (CommonTree)input.LT(1);
 15755  0
                     LANG404=(CommonTree)match(input,LANG,FOLLOW_LANG_in_builtInCall3150); 
 15756  0
                     LANG404_tree = (CommonTree)adaptor.dupNode(LANG404);
 15757  
 
 15758  
 
 15759  0
                     root_1 = (CommonTree)adaptor.becomeRoot(LANG404_tree, root_1);
 15760  
 
 15761  
 
 15762  0
                     match(input, Token.DOWN, null); 
 15763  0
                     _last = (CommonTree)input.LT(1);
 15764  0
                     pushFollow(FOLLOW_expression_in_builtInCall3152);
 15765  0
                     expression405=expression();
 15766  
 
 15767  0
                     state._fsp--;
 15768  
 
 15769  0
                     adaptor.addChild(root_1, expression405.getTree());
 15770  
 
 15771  
 
 15772  0
                     match(input, Token.UP, null); 
 15773  0
                     adaptor.addChild(root_0, root_1);
 15774  0
                     _last = _save_last_1;
 15775  
                     }
 15776  
 
 15777  
 
 15778  
                     }
 15779  0
                     break;
 15780  
                 case 3 :
 15781  
                     // com\\googlecode\\sparkleg\\SparqlT.g:455:7: ^( LANGMATCHES ( expression )+ )
 15782  
                     {
 15783  0
                     root_0 = (CommonTree)adaptor.nil();
 15784  
 
 15785  
 
 15786  0
                     _last = (CommonTree)input.LT(1);
 15787  
                     {
 15788  0
                     CommonTree _save_last_1 = _last;
 15789  0
                     CommonTree _first_1 = null;
 15790  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 15791  0
                     _last = (CommonTree)input.LT(1);
 15792  0
                     LANGMATCHES406=(CommonTree)match(input,LANGMATCHES,FOLLOW_LANGMATCHES_in_builtInCall3162); 
 15793  0
                     LANGMATCHES406_tree = (CommonTree)adaptor.dupNode(LANGMATCHES406);
 15794  
 
 15795  
 
 15796  0
                     root_1 = (CommonTree)adaptor.becomeRoot(LANGMATCHES406_tree, root_1);
 15797  
 
 15798  
 
 15799  0
                     match(input, Token.DOWN, null); 
 15800  
                     // com\\googlecode\\sparkleg\\SparqlT.g:455:21: ( expression )+
 15801  0
                     int cnt129=0;
 15802  
                     loop129:
 15803  
                     do {
 15804  0
                         int alt129=2;
 15805  0
                         switch ( input.LA(1) ) {
 15806  
                         case AND:
 15807  
                         case ASTERISK:
 15808  
                         case DECIMAL_NEGATIVE:
 15809  
                         case DECIMAL_POSITIVE:
 15810  
                         case DIVIDE:
 15811  
                         case DOUBLE_NEGATIVE:
 15812  
                         case DOUBLE_POSITIVE:
 15813  
                         case EQUAL:
 15814  
                         case GREATER:
 15815  
                         case GREATER_EQUAL:
 15816  
                         case IN:
 15817  
                         case INTEGER_NEGATIVE:
 15818  
                         case INTEGER_POSITIVE:
 15819  
                         case LESS:
 15820  
                         case LESS_EQUAL:
 15821  
                         case MINUS:
 15822  
                         case NOT:
 15823  
                         case NOT_EQUAL:
 15824  
                         case OR:
 15825  
                         case PLUS:
 15826  
                         case UNARY:
 15827  
                             {
 15828  0
                             alt129=1;
 15829  
                             }
 15830  
                             break;
 15831  
 
 15832  
                         }
 15833  
 
 15834  0
                         switch (alt129) {
 15835  
                             case 1 :
 15836  
                                 // com\\googlecode\\sparkleg\\SparqlT.g:455:21: expression
 15837  
                                 {
 15838  0
                                 _last = (CommonTree)input.LT(1);
 15839  0
                                 pushFollow(FOLLOW_expression_in_builtInCall3164);
 15840  0
                                 expression407=expression();
 15841  
 
 15842  0
                                 state._fsp--;
 15843  
 
 15844  0
                                 adaptor.addChild(root_1, expression407.getTree());
 15845  
 
 15846  
 
 15847  
                                 }
 15848  0
                                 break;
 15849  
 
 15850  
                             default :
 15851  0
                                 if ( cnt129 >= 1 ) break loop129;
 15852  0
                                 EarlyExitException eee =
 15853  
                                     new EarlyExitException(129, input);
 15854  0
                                 throw eee;
 15855  
                         }
 15856  0
                         cnt129++;
 15857  0
                     } while (true);
 15858  
 
 15859  
 
 15860  0
                     match(input, Token.UP, null); 
 15861  0
                     adaptor.addChild(root_0, root_1);
 15862  0
                     _last = _save_last_1;
 15863  
                     }
 15864  
 
 15865  
 
 15866  
                     }
 15867  0
                     break;
 15868  
                 case 4 :
 15869  
                     // com\\googlecode\\sparkleg\\SparqlT.g:456:7: ^( DATATYPE expression )
 15870  
                     {
 15871  0
                     root_0 = (CommonTree)adaptor.nil();
 15872  
 
 15873  
 
 15874  0
                     _last = (CommonTree)input.LT(1);
 15875  
                     {
 15876  0
                     CommonTree _save_last_1 = _last;
 15877  0
                     CommonTree _first_1 = null;
 15878  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 15879  0
                     _last = (CommonTree)input.LT(1);
 15880  0
                     DATATYPE408=(CommonTree)match(input,DATATYPE,FOLLOW_DATATYPE_in_builtInCall3175); 
 15881  0
                     DATATYPE408_tree = (CommonTree)adaptor.dupNode(DATATYPE408);
 15882  
 
 15883  
 
 15884  0
                     root_1 = (CommonTree)adaptor.becomeRoot(DATATYPE408_tree, root_1);
 15885  
 
 15886  
 
 15887  0
                     match(input, Token.DOWN, null); 
 15888  0
                     _last = (CommonTree)input.LT(1);
 15889  0
                     pushFollow(FOLLOW_expression_in_builtInCall3177);
 15890  0
                     expression409=expression();
 15891  
 
 15892  0
                     state._fsp--;
 15893  
 
 15894  0
                     adaptor.addChild(root_1, expression409.getTree());
 15895  
 
 15896  
 
 15897  0
                     match(input, Token.UP, null); 
 15898  0
                     adaptor.addChild(root_0, root_1);
 15899  0
                     _last = _save_last_1;
 15900  
                     }
 15901  
 
 15902  
 
 15903  
                     }
 15904  0
                     break;
 15905  
                 case 5 :
 15906  
                     // com\\googlecode\\sparkleg\\SparqlT.g:457:7: ^( BOUND var )
 15907  
                     {
 15908  0
                     root_0 = (CommonTree)adaptor.nil();
 15909  
 
 15910  
 
 15911  0
                     _last = (CommonTree)input.LT(1);
 15912  
                     {
 15913  0
                     CommonTree _save_last_1 = _last;
 15914  0
                     CommonTree _first_1 = null;
 15915  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 15916  0
                     _last = (CommonTree)input.LT(1);
 15917  0
                     BOUND410=(CommonTree)match(input,BOUND,FOLLOW_BOUND_in_builtInCall3187); 
 15918  0
                     BOUND410_tree = (CommonTree)adaptor.dupNode(BOUND410);
 15919  
 
 15920  
 
 15921  0
                     root_1 = (CommonTree)adaptor.becomeRoot(BOUND410_tree, root_1);
 15922  
 
 15923  
 
 15924  0
                     match(input, Token.DOWN, null); 
 15925  0
                     _last = (CommonTree)input.LT(1);
 15926  0
                     pushFollow(FOLLOW_var_in_builtInCall3189);
 15927  0
                     var411=var();
 15928  
 
 15929  0
                     state._fsp--;
 15930  
 
 15931  0
                     adaptor.addChild(root_1, var411.getTree());
 15932  
 
 15933  
 
 15934  0
                     match(input, Token.UP, null); 
 15935  0
                     adaptor.addChild(root_0, root_1);
 15936  0
                     _last = _save_last_1;
 15937  
                     }
 15938  
 
 15939  
 
 15940  
                     }
 15941  0
                     break;
 15942  
                 case 6 :
 15943  
                     // com\\googlecode\\sparkleg\\SparqlT.g:458:7: ^( IRI expression )
 15944  
                     {
 15945  0
                     root_0 = (CommonTree)adaptor.nil();
 15946  
 
 15947  
 
 15948  0
                     _last = (CommonTree)input.LT(1);
 15949  
                     {
 15950  0
                     CommonTree _save_last_1 = _last;
 15951  0
                     CommonTree _first_1 = null;
 15952  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 15953  0
                     _last = (CommonTree)input.LT(1);
 15954  0
                     IRI412=(CommonTree)match(input,IRI,FOLLOW_IRI_in_builtInCall3199); 
 15955  0
                     IRI412_tree = (CommonTree)adaptor.dupNode(IRI412);
 15956  
 
 15957  
 
 15958  0
                     root_1 = (CommonTree)adaptor.becomeRoot(IRI412_tree, root_1);
 15959  
 
 15960  
 
 15961  0
                     match(input, Token.DOWN, null); 
 15962  0
                     _last = (CommonTree)input.LT(1);
 15963  0
                     pushFollow(FOLLOW_expression_in_builtInCall3201);
 15964  0
                     expression413=expression();
 15965  
 
 15966  0
                     state._fsp--;
 15967  
 
 15968  0
                     adaptor.addChild(root_1, expression413.getTree());
 15969  
 
 15970  
 
 15971  0
                     match(input, Token.UP, null); 
 15972  0
                     adaptor.addChild(root_0, root_1);
 15973  0
                     _last = _save_last_1;
 15974  
                     }
 15975  
 
 15976  
 
 15977  
                     }
 15978  0
                     break;
 15979  
                 case 7 :
 15980  
                     // com\\googlecode\\sparkleg\\SparqlT.g:459:7: ^( URI expression )
 15981  
                     {
 15982  0
                     root_0 = (CommonTree)adaptor.nil();
 15983  
 
 15984  
 
 15985  0
                     _last = (CommonTree)input.LT(1);
 15986  
                     {
 15987  0
                     CommonTree _save_last_1 = _last;
 15988  0
                     CommonTree _first_1 = null;
 15989  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 15990  0
                     _last = (CommonTree)input.LT(1);
 15991  0
                     URI414=(CommonTree)match(input,URI,FOLLOW_URI_in_builtInCall3211); 
 15992  0
                     URI414_tree = (CommonTree)adaptor.dupNode(URI414);
 15993  
 
 15994  
 
 15995  0
                     root_1 = (CommonTree)adaptor.becomeRoot(URI414_tree, root_1);
 15996  
 
 15997  
 
 15998  0
                     match(input, Token.DOWN, null); 
 15999  0
                     _last = (CommonTree)input.LT(1);
 16000  0
                     pushFollow(FOLLOW_expression_in_builtInCall3213);
 16001  0
                     expression415=expression();
 16002  
 
 16003  0
                     state._fsp--;
 16004  
 
 16005  0
                     adaptor.addChild(root_1, expression415.getTree());
 16006  
 
 16007  
 
 16008  0
                     match(input, Token.UP, null); 
 16009  0
                     adaptor.addChild(root_0, root_1);
 16010  0
                     _last = _save_last_1;
 16011  
                     }
 16012  
 
 16013  
 
 16014  
                     }
 16015  0
                     break;
 16016  
                 case 8 :
 16017  
                     // com\\googlecode\\sparkleg\\SparqlT.g:460:7: ^( BNODE expression )
 16018  
                     {
 16019  0
                     root_0 = (CommonTree)adaptor.nil();
 16020  
 
 16021  
 
 16022  0
                     _last = (CommonTree)input.LT(1);
 16023  
                     {
 16024  0
                     CommonTree _save_last_1 = _last;
 16025  0
                     CommonTree _first_1 = null;
 16026  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 16027  0
                     _last = (CommonTree)input.LT(1);
 16028  0
                     BNODE416=(CommonTree)match(input,BNODE,FOLLOW_BNODE_in_builtInCall3223); 
 16029  0
                     BNODE416_tree = (CommonTree)adaptor.dupNode(BNODE416);
 16030  
 
 16031  
 
 16032  0
                     root_1 = (CommonTree)adaptor.becomeRoot(BNODE416_tree, root_1);
 16033  
 
 16034  
 
 16035  0
                     match(input, Token.DOWN, null); 
 16036  0
                     _last = (CommonTree)input.LT(1);
 16037  0
                     pushFollow(FOLLOW_expression_in_builtInCall3225);
 16038  0
                     expression417=expression();
 16039  
 
 16040  0
                     state._fsp--;
 16041  
 
 16042  0
                     adaptor.addChild(root_1, expression417.getTree());
 16043  
 
 16044  
 
 16045  0
                     match(input, Token.UP, null); 
 16046  0
                     adaptor.addChild(root_0, root_1);
 16047  0
                     _last = _save_last_1;
 16048  
                     }
 16049  
 
 16050  
 
 16051  
                     }
 16052  0
                     break;
 16053  
                 case 9 :
 16054  
                     // com\\googlecode\\sparkleg\\SparqlT.g:461:7: BNODE
 16055  
                     {
 16056  0
                     root_0 = (CommonTree)adaptor.nil();
 16057  
 
 16058  
 
 16059  0
                     _last = (CommonTree)input.LT(1);
 16060  0
                     BNODE418=(CommonTree)match(input,BNODE,FOLLOW_BNODE_in_builtInCall3234); 
 16061  0
                     BNODE418_tree = (CommonTree)adaptor.dupNode(BNODE418);
 16062  
 
 16063  
 
 16064  0
                     adaptor.addChild(root_0, BNODE418_tree);
 16065  
 
 16066  
 
 16067  
                     }
 16068  0
                     break;
 16069  
                 case 10 :
 16070  
                     // com\\googlecode\\sparkleg\\SparqlT.g:462:7: RAND
 16071  
                     {
 16072  0
                     root_0 = (CommonTree)adaptor.nil();
 16073  
 
 16074  
 
 16075  0
                     _last = (CommonTree)input.LT(1);
 16076  0
                     RAND419=(CommonTree)match(input,RAND,FOLLOW_RAND_in_builtInCall3242); 
 16077  0
                     RAND419_tree = (CommonTree)adaptor.dupNode(RAND419);
 16078  
 
 16079  
 
 16080  0
                     adaptor.addChild(root_0, RAND419_tree);
 16081  
 
 16082  
 
 16083  
                     }
 16084  0
                     break;
 16085  
                 case 11 :
 16086  
                     // com\\googlecode\\sparkleg\\SparqlT.g:463:7: ^( ABS expression )
 16087  
                     {
 16088  0
                     root_0 = (CommonTree)adaptor.nil();
 16089  
 
 16090  
 
 16091  0
                     _last = (CommonTree)input.LT(1);
 16092  
                     {
 16093  0
                     CommonTree _save_last_1 = _last;
 16094  0
                     CommonTree _first_1 = null;
 16095  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 16096  0
                     _last = (CommonTree)input.LT(1);
 16097  0
                     ABS420=(CommonTree)match(input,ABS,FOLLOW_ABS_in_builtInCall3251); 
 16098  0
                     ABS420_tree = (CommonTree)adaptor.dupNode(ABS420);
 16099  
 
 16100  
 
 16101  0
                     root_1 = (CommonTree)adaptor.becomeRoot(ABS420_tree, root_1);
 16102  
 
 16103  
 
 16104  0
                     match(input, Token.DOWN, null); 
 16105  0
                     _last = (CommonTree)input.LT(1);
 16106  0
                     pushFollow(FOLLOW_expression_in_builtInCall3253);
 16107  0
                     expression421=expression();
 16108  
 
 16109  0
                     state._fsp--;
 16110  
 
 16111  0
                     adaptor.addChild(root_1, expression421.getTree());
 16112  
 
 16113  
 
 16114  0
                     match(input, Token.UP, null); 
 16115  0
                     adaptor.addChild(root_0, root_1);
 16116  0
                     _last = _save_last_1;
 16117  
                     }
 16118  
 
 16119  
 
 16120  
                     }
 16121  0
                     break;
 16122  
                 case 12 :
 16123  
                     // com\\googlecode\\sparkleg\\SparqlT.g:464:7: ^( CEIL expression )
 16124  
                     {
 16125  0
                     root_0 = (CommonTree)adaptor.nil();
 16126  
 
 16127  
 
 16128  0
                     _last = (CommonTree)input.LT(1);
 16129  
                     {
 16130  0
                     CommonTree _save_last_1 = _last;
 16131  0
                     CommonTree _first_1 = null;
 16132  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 16133  0
                     _last = (CommonTree)input.LT(1);
 16134  0
                     CEIL422=(CommonTree)match(input,CEIL,FOLLOW_CEIL_in_builtInCall3263); 
 16135  0
                     CEIL422_tree = (CommonTree)adaptor.dupNode(CEIL422);
 16136  
 
 16137  
 
 16138  0
                     root_1 = (CommonTree)adaptor.becomeRoot(CEIL422_tree, root_1);
 16139  
 
 16140  
 
 16141  0
                     match(input, Token.DOWN, null); 
 16142  0
                     _last = (CommonTree)input.LT(1);
 16143  0
                     pushFollow(FOLLOW_expression_in_builtInCall3265);
 16144  0
                     expression423=expression();
 16145  
 
 16146  0
                     state._fsp--;
 16147  
 
 16148  0
                     adaptor.addChild(root_1, expression423.getTree());
 16149  
 
 16150  
 
 16151  0
                     match(input, Token.UP, null); 
 16152  0
                     adaptor.addChild(root_0, root_1);
 16153  0
                     _last = _save_last_1;
 16154  
                     }
 16155  
 
 16156  
 
 16157  
                     }
 16158  0
                     break;
 16159  
                 case 13 :
 16160  
                     // com\\googlecode\\sparkleg\\SparqlT.g:465:7: ^( FLOOR expression )
 16161  
                     {
 16162  0
                     root_0 = (CommonTree)adaptor.nil();
 16163  
 
 16164  
 
 16165  0
                     _last = (CommonTree)input.LT(1);
 16166  
                     {
 16167  0
                     CommonTree _save_last_1 = _last;
 16168  0
                     CommonTree _first_1 = null;
 16169  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 16170  0
                     _last = (CommonTree)input.LT(1);
 16171  0
                     FLOOR424=(CommonTree)match(input,FLOOR,FOLLOW_FLOOR_in_builtInCall3275); 
 16172  0
                     FLOOR424_tree = (CommonTree)adaptor.dupNode(FLOOR424);
 16173  
 
 16174  
 
 16175  0
                     root_1 = (CommonTree)adaptor.becomeRoot(FLOOR424_tree, root_1);
 16176  
 
 16177  
 
 16178  0
                     match(input, Token.DOWN, null); 
 16179  0
                     _last = (CommonTree)input.LT(1);
 16180  0
                     pushFollow(FOLLOW_expression_in_builtInCall3277);
 16181  0
                     expression425=expression();
 16182  
 
 16183  0
                     state._fsp--;
 16184  
 
 16185  0
                     adaptor.addChild(root_1, expression425.getTree());
 16186  
 
 16187  
 
 16188  0
                     match(input, Token.UP, null); 
 16189  0
                     adaptor.addChild(root_0, root_1);
 16190  0
                     _last = _save_last_1;
 16191  
                     }
 16192  
 
 16193  
 
 16194  
                     }
 16195  0
                     break;
 16196  
                 case 14 :
 16197  
                     // com\\googlecode\\sparkleg\\SparqlT.g:466:7: ^( ROUND expression )
 16198  
                     {
 16199  0
                     root_0 = (CommonTree)adaptor.nil();
 16200  
 
 16201  
 
 16202  0
                     _last = (CommonTree)input.LT(1);
 16203  
                     {
 16204  0
                     CommonTree _save_last_1 = _last;
 16205  0
                     CommonTree _first_1 = null;
 16206  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 16207  0
                     _last = (CommonTree)input.LT(1);
 16208  0
                     ROUND426=(CommonTree)match(input,ROUND,FOLLOW_ROUND_in_builtInCall3287); 
 16209  0
                     ROUND426_tree = (CommonTree)adaptor.dupNode(ROUND426);
 16210  
 
 16211  
 
 16212  0
                     root_1 = (CommonTree)adaptor.becomeRoot(ROUND426_tree, root_1);
 16213  
 
 16214  
 
 16215  0
                     match(input, Token.DOWN, null); 
 16216  0
                     _last = (CommonTree)input.LT(1);
 16217  0
                     pushFollow(FOLLOW_expression_in_builtInCall3289);
 16218  0
                     expression427=expression();
 16219  
 
 16220  0
                     state._fsp--;
 16221  
 
 16222  0
                     adaptor.addChild(root_1, expression427.getTree());
 16223  
 
 16224  
 
 16225  0
                     match(input, Token.UP, null); 
 16226  0
                     adaptor.addChild(root_0, root_1);
 16227  0
                     _last = _save_last_1;
 16228  
                     }
 16229  
 
 16230  
 
 16231  
                     }
 16232  0
                     break;
 16233  
                 case 15 :
 16234  
                     // com\\googlecode\\sparkleg\\SparqlT.g:467:7: ^( CONCAT expressionList )
 16235  
                     {
 16236  0
                     root_0 = (CommonTree)adaptor.nil();
 16237  
 
 16238  
 
 16239  0
                     _last = (CommonTree)input.LT(1);
 16240  
                     {
 16241  0
                     CommonTree _save_last_1 = _last;
 16242  0
                     CommonTree _first_1 = null;
 16243  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 16244  0
                     _last = (CommonTree)input.LT(1);
 16245  0
                     CONCAT428=(CommonTree)match(input,CONCAT,FOLLOW_CONCAT_in_builtInCall3299); 
 16246  0
                     CONCAT428_tree = (CommonTree)adaptor.dupNode(CONCAT428);
 16247  
 
 16248  
 
 16249  0
                     root_1 = (CommonTree)adaptor.becomeRoot(CONCAT428_tree, root_1);
 16250  
 
 16251  
 
 16252  0
                     match(input, Token.DOWN, null); 
 16253  0
                     _last = (CommonTree)input.LT(1);
 16254  0
                     pushFollow(FOLLOW_expressionList_in_builtInCall3301);
 16255  0
                     expressionList429=expressionList();
 16256  
 
 16257  0
                     state._fsp--;
 16258  
 
 16259  0
                     adaptor.addChild(root_1, expressionList429.getTree());
 16260  
 
 16261  
 
 16262  0
                     match(input, Token.UP, null); 
 16263  0
                     adaptor.addChild(root_0, root_1);
 16264  0
                     _last = _save_last_1;
 16265  
                     }
 16266  
 
 16267  
 
 16268  
                     }
 16269  0
                     break;
 16270  
                 case 16 :
 16271  
                     // com\\googlecode\\sparkleg\\SparqlT.g:468:7: subStringExpression
 16272  
                     {
 16273  0
                     root_0 = (CommonTree)adaptor.nil();
 16274  
 
 16275  
 
 16276  0
                     _last = (CommonTree)input.LT(1);
 16277  0
                     pushFollow(FOLLOW_subStringExpression_in_builtInCall3310);
 16278  0
                     subStringExpression430=subStringExpression();
 16279  
 
 16280  0
                     state._fsp--;
 16281  
 
 16282  0
                     adaptor.addChild(root_0, subStringExpression430.getTree());
 16283  
 
 16284  
 
 16285  
                     }
 16286  0
                     break;
 16287  
                 case 17 :
 16288  
                     // com\\googlecode\\sparkleg\\SparqlT.g:469:7: ^( STRLEN expression )
 16289  
                     {
 16290  0
                     root_0 = (CommonTree)adaptor.nil();
 16291  
 
 16292  
 
 16293  0
                     _last = (CommonTree)input.LT(1);
 16294  
                     {
 16295  0
                     CommonTree _save_last_1 = _last;
 16296  0
                     CommonTree _first_1 = null;
 16297  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 16298  0
                     _last = (CommonTree)input.LT(1);
 16299  0
                     STRLEN431=(CommonTree)match(input,STRLEN,FOLLOW_STRLEN_in_builtInCall3319); 
 16300  0
                     STRLEN431_tree = (CommonTree)adaptor.dupNode(STRLEN431);
 16301  
 
 16302  
 
 16303  0
                     root_1 = (CommonTree)adaptor.becomeRoot(STRLEN431_tree, root_1);
 16304  
 
 16305  
 
 16306  0
                     match(input, Token.DOWN, null); 
 16307  0
                     _last = (CommonTree)input.LT(1);
 16308  0
                     pushFollow(FOLLOW_expression_in_builtInCall3321);
 16309  0
                     expression432=expression();
 16310  
 
 16311  0
                     state._fsp--;
 16312  
 
 16313  0
                     adaptor.addChild(root_1, expression432.getTree());
 16314  
 
 16315  
 
 16316  0
                     match(input, Token.UP, null); 
 16317  0
                     adaptor.addChild(root_0, root_1);
 16318  0
                     _last = _save_last_1;
 16319  
                     }
 16320  
 
 16321  
 
 16322  
                     }
 16323  0
                     break;
 16324  
                 case 18 :
 16325  
                     // com\\googlecode\\sparkleg\\SparqlT.g:470:7: ^( UCASE expression )
 16326  
                     {
 16327  0
                     root_0 = (CommonTree)adaptor.nil();
 16328  
 
 16329  
 
 16330  0
                     _last = (CommonTree)input.LT(1);
 16331  
                     {
 16332  0
                     CommonTree _save_last_1 = _last;
 16333  0
                     CommonTree _first_1 = null;
 16334  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 16335  0
                     _last = (CommonTree)input.LT(1);
 16336  0
                     UCASE433=(CommonTree)match(input,UCASE,FOLLOW_UCASE_in_builtInCall3331); 
 16337  0
                     UCASE433_tree = (CommonTree)adaptor.dupNode(UCASE433);
 16338  
 
 16339  
 
 16340  0
                     root_1 = (CommonTree)adaptor.becomeRoot(UCASE433_tree, root_1);
 16341  
 
 16342  
 
 16343  0
                     match(input, Token.DOWN, null); 
 16344  0
                     _last = (CommonTree)input.LT(1);
 16345  0
                     pushFollow(FOLLOW_expression_in_builtInCall3333);
 16346  0
                     expression434=expression();
 16347  
 
 16348  0
                     state._fsp--;
 16349  
 
 16350  0
                     adaptor.addChild(root_1, expression434.getTree());
 16351  
 
 16352  
 
 16353  0
                     match(input, Token.UP, null); 
 16354  0
                     adaptor.addChild(root_0, root_1);
 16355  0
                     _last = _save_last_1;
 16356  
                     }
 16357  
 
 16358  
 
 16359  
                     }
 16360  0
                     break;
 16361  
                 case 19 :
 16362  
                     // com\\googlecode\\sparkleg\\SparqlT.g:471:7: ^( LCASE expression )
 16363  
                     {
 16364  0
                     root_0 = (CommonTree)adaptor.nil();
 16365  
 
 16366  
 
 16367  0
                     _last = (CommonTree)input.LT(1);
 16368  
                     {
 16369  0
                     CommonTree _save_last_1 = _last;
 16370  0
                     CommonTree _first_1 = null;
 16371  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 16372  0
                     _last = (CommonTree)input.LT(1);
 16373  0
                     LCASE435=(CommonTree)match(input,LCASE,FOLLOW_LCASE_in_builtInCall3343); 
 16374  0
                     LCASE435_tree = (CommonTree)adaptor.dupNode(LCASE435);
 16375  
 
 16376  
 
 16377  0
                     root_1 = (CommonTree)adaptor.becomeRoot(LCASE435_tree, root_1);
 16378  
 
 16379  
 
 16380  0
                     match(input, Token.DOWN, null); 
 16381  0
                     _last = (CommonTree)input.LT(1);
 16382  0
                     pushFollow(FOLLOW_expression_in_builtInCall3345);
 16383  0
                     expression436=expression();
 16384  
 
 16385  0
                     state._fsp--;
 16386  
 
 16387  0
                     adaptor.addChild(root_1, expression436.getTree());
 16388  
 
 16389  
 
 16390  0
                     match(input, Token.UP, null); 
 16391  0
                     adaptor.addChild(root_0, root_1);
 16392  0
                     _last = _save_last_1;
 16393  
                     }
 16394  
 
 16395  
 
 16396  
                     }
 16397  0
                     break;
 16398  
                 case 20 :
 16399  
                     // com\\googlecode\\sparkleg\\SparqlT.g:472:7: ^( ENCODE_FOR_URI expression )
 16400  
                     {
 16401  0
                     root_0 = (CommonTree)adaptor.nil();
 16402  
 
 16403  
 
 16404  0
                     _last = (CommonTree)input.LT(1);
 16405  
                     {
 16406  0
                     CommonTree _save_last_1 = _last;
 16407  0
                     CommonTree _first_1 = null;
 16408  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 16409  0
                     _last = (CommonTree)input.LT(1);
 16410  0
                     ENCODE_FOR_URI437=(CommonTree)match(input,ENCODE_FOR_URI,FOLLOW_ENCODE_FOR_URI_in_builtInCall3355); 
 16411  0
                     ENCODE_FOR_URI437_tree = (CommonTree)adaptor.dupNode(ENCODE_FOR_URI437);
 16412  
 
 16413  
 
 16414  0
                     root_1 = (CommonTree)adaptor.becomeRoot(ENCODE_FOR_URI437_tree, root_1);
 16415  
 
 16416  
 
 16417  0
                     match(input, Token.DOWN, null); 
 16418  0
                     _last = (CommonTree)input.LT(1);
 16419  0
                     pushFollow(FOLLOW_expression_in_builtInCall3357);
 16420  0
                     expression438=expression();
 16421  
 
 16422  0
                     state._fsp--;
 16423  
 
 16424  0
                     adaptor.addChild(root_1, expression438.getTree());
 16425  
 
 16426  
 
 16427  0
                     match(input, Token.UP, null); 
 16428  0
                     adaptor.addChild(root_0, root_1);
 16429  0
                     _last = _save_last_1;
 16430  
                     }
 16431  
 
 16432  
 
 16433  
                     }
 16434  0
                     break;
 16435  
                 case 21 :
 16436  
                     // com\\googlecode\\sparkleg\\SparqlT.g:473:7: ^( CONTAINS expression expression )
 16437  
                     {
 16438  0
                     root_0 = (CommonTree)adaptor.nil();
 16439  
 
 16440  
 
 16441  0
                     _last = (CommonTree)input.LT(1);
 16442  
                     {
 16443  0
                     CommonTree _save_last_1 = _last;
 16444  0
                     CommonTree _first_1 = null;
 16445  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 16446  0
                     _last = (CommonTree)input.LT(1);
 16447  0
                     CONTAINS439=(CommonTree)match(input,CONTAINS,FOLLOW_CONTAINS_in_builtInCall3367); 
 16448  0
                     CONTAINS439_tree = (CommonTree)adaptor.dupNode(CONTAINS439);
 16449  
 
 16450  
 
 16451  0
                     root_1 = (CommonTree)adaptor.becomeRoot(CONTAINS439_tree, root_1);
 16452  
 
 16453  
 
 16454  0
                     match(input, Token.DOWN, null); 
 16455  0
                     _last = (CommonTree)input.LT(1);
 16456  0
                     pushFollow(FOLLOW_expression_in_builtInCall3369);
 16457  0
                     expression440=expression();
 16458  
 
 16459  0
                     state._fsp--;
 16460  
 
 16461  0
                     adaptor.addChild(root_1, expression440.getTree());
 16462  
 
 16463  
 
 16464  0
                     _last = (CommonTree)input.LT(1);
 16465  0
                     pushFollow(FOLLOW_expression_in_builtInCall3371);
 16466  0
                     expression441=expression();
 16467  
 
 16468  0
                     state._fsp--;
 16469  
 
 16470  0
                     adaptor.addChild(root_1, expression441.getTree());
 16471  
 
 16472  
 
 16473  0
                     match(input, Token.UP, null); 
 16474  0
                     adaptor.addChild(root_0, root_1);
 16475  0
                     _last = _save_last_1;
 16476  
                     }
 16477  
 
 16478  
 
 16479  
                     }
 16480  0
                     break;
 16481  
                 case 22 :
 16482  
                     // com\\googlecode\\sparkleg\\SparqlT.g:474:7: ^( STRSTARTS expression expression )
 16483  
                     {
 16484  0
                     root_0 = (CommonTree)adaptor.nil();
 16485  
 
 16486  
 
 16487  0
                     _last = (CommonTree)input.LT(1);
 16488  
                     {
 16489  0
                     CommonTree _save_last_1 = _last;
 16490  0
                     CommonTree _first_1 = null;
 16491  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 16492  0
                     _last = (CommonTree)input.LT(1);
 16493  0
                     STRSTARTS442=(CommonTree)match(input,STRSTARTS,FOLLOW_STRSTARTS_in_builtInCall3381); 
 16494  0
                     STRSTARTS442_tree = (CommonTree)adaptor.dupNode(STRSTARTS442);
 16495  
 
 16496  
 
 16497  0
                     root_1 = (CommonTree)adaptor.becomeRoot(STRSTARTS442_tree, root_1);
 16498  
 
 16499  
 
 16500  0
                     match(input, Token.DOWN, null); 
 16501  0
                     _last = (CommonTree)input.LT(1);
 16502  0
                     pushFollow(FOLLOW_expression_in_builtInCall3383);
 16503  0
                     expression443=expression();
 16504  
 
 16505  0
                     state._fsp--;
 16506  
 
 16507  0
                     adaptor.addChild(root_1, expression443.getTree());
 16508  
 
 16509  
 
 16510  0
                     _last = (CommonTree)input.LT(1);
 16511  0
                     pushFollow(FOLLOW_expression_in_builtInCall3385);
 16512  0
                     expression444=expression();
 16513  
 
 16514  0
                     state._fsp--;
 16515  
 
 16516  0
                     adaptor.addChild(root_1, expression444.getTree());
 16517  
 
 16518  
 
 16519  0
                     match(input, Token.UP, null); 
 16520  0
                     adaptor.addChild(root_0, root_1);
 16521  0
                     _last = _save_last_1;
 16522  
                     }
 16523  
 
 16524  
 
 16525  
                     }
 16526  0
                     break;
 16527  
                 case 23 :
 16528  
                     // com\\googlecode\\sparkleg\\SparqlT.g:475:7: ^( STRENDS expression expression )
 16529  
                     {
 16530  0
                     root_0 = (CommonTree)adaptor.nil();
 16531  
 
 16532  
 
 16533  0
                     _last = (CommonTree)input.LT(1);
 16534  
                     {
 16535  0
                     CommonTree _save_last_1 = _last;
 16536  0
                     CommonTree _first_1 = null;
 16537  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 16538  0
                     _last = (CommonTree)input.LT(1);
 16539  0
                     STRENDS445=(CommonTree)match(input,STRENDS,FOLLOW_STRENDS_in_builtInCall3395); 
 16540  0
                     STRENDS445_tree = (CommonTree)adaptor.dupNode(STRENDS445);
 16541  
 
 16542  
 
 16543  0
                     root_1 = (CommonTree)adaptor.becomeRoot(STRENDS445_tree, root_1);
 16544  
 
 16545  
 
 16546  0
                     match(input, Token.DOWN, null); 
 16547  0
                     _last = (CommonTree)input.LT(1);
 16548  0
                     pushFollow(FOLLOW_expression_in_builtInCall3397);
 16549  0
                     expression446=expression();
 16550  
 
 16551  0
                     state._fsp--;
 16552  
 
 16553  0
                     adaptor.addChild(root_1, expression446.getTree());
 16554  
 
 16555  
 
 16556  0
                     _last = (CommonTree)input.LT(1);
 16557  0
                     pushFollow(FOLLOW_expression_in_builtInCall3399);
 16558  0
                     expression447=expression();
 16559  
 
 16560  0
                     state._fsp--;
 16561  
 
 16562  0
                     adaptor.addChild(root_1, expression447.getTree());
 16563  
 
 16564  
 
 16565  0
                     match(input, Token.UP, null); 
 16566  0
                     adaptor.addChild(root_0, root_1);
 16567  0
                     _last = _save_last_1;
 16568  
                     }
 16569  
 
 16570  
 
 16571  
                     }
 16572  0
                     break;
 16573  
                 case 24 :
 16574  
                     // com\\googlecode\\sparkleg\\SparqlT.g:476:7: ^( STRBEFORE expression expression )
 16575  
                     {
 16576  0
                     root_0 = (CommonTree)adaptor.nil();
 16577  
 
 16578  
 
 16579  0
                     _last = (CommonTree)input.LT(1);
 16580  
                     {
 16581  0
                     CommonTree _save_last_1 = _last;
 16582  0
                     CommonTree _first_1 = null;
 16583  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 16584  0
                     _last = (CommonTree)input.LT(1);
 16585  0
                     STRBEFORE448=(CommonTree)match(input,STRBEFORE,FOLLOW_STRBEFORE_in_builtInCall3409); 
 16586  0
                     STRBEFORE448_tree = (CommonTree)adaptor.dupNode(STRBEFORE448);
 16587  
 
 16588  
 
 16589  0
                     root_1 = (CommonTree)adaptor.becomeRoot(STRBEFORE448_tree, root_1);
 16590  
 
 16591  
 
 16592  0
                     match(input, Token.DOWN, null); 
 16593  0
                     _last = (CommonTree)input.LT(1);
 16594  0
                     pushFollow(FOLLOW_expression_in_builtInCall3411);
 16595  0
                     expression449=expression();
 16596  
 
 16597  0
                     state._fsp--;
 16598  
 
 16599  0
                     adaptor.addChild(root_1, expression449.getTree());
 16600  
 
 16601  
 
 16602  0
                     _last = (CommonTree)input.LT(1);
 16603  0
                     pushFollow(FOLLOW_expression_in_builtInCall3413);
 16604  0
                     expression450=expression();
 16605  
 
 16606  0
                     state._fsp--;
 16607  
 
 16608  0
                     adaptor.addChild(root_1, expression450.getTree());
 16609  
 
 16610  
 
 16611  0
                     match(input, Token.UP, null); 
 16612  0
                     adaptor.addChild(root_0, root_1);
 16613  0
                     _last = _save_last_1;
 16614  
                     }
 16615  
 
 16616  
 
 16617  
                     }
 16618  0
                     break;
 16619  
                 case 25 :
 16620  
                     // com\\googlecode\\sparkleg\\SparqlT.g:477:7: ^( STRAFTER expression expression )
 16621  
                     {
 16622  0
                     root_0 = (CommonTree)adaptor.nil();
 16623  
 
 16624  
 
 16625  0
                     _last = (CommonTree)input.LT(1);
 16626  
                     {
 16627  0
                     CommonTree _save_last_1 = _last;
 16628  0
                     CommonTree _first_1 = null;
 16629  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 16630  0
                     _last = (CommonTree)input.LT(1);
 16631  0
                     STRAFTER451=(CommonTree)match(input,STRAFTER,FOLLOW_STRAFTER_in_builtInCall3423); 
 16632  0
                     STRAFTER451_tree = (CommonTree)adaptor.dupNode(STRAFTER451);
 16633  
 
 16634  
 
 16635  0
                     root_1 = (CommonTree)adaptor.becomeRoot(STRAFTER451_tree, root_1);
 16636  
 
 16637  
 
 16638  0
                     match(input, Token.DOWN, null); 
 16639  0
                     _last = (CommonTree)input.LT(1);
 16640  0
                     pushFollow(FOLLOW_expression_in_builtInCall3425);
 16641  0
                     expression452=expression();
 16642  
 
 16643  0
                     state._fsp--;
 16644  
 
 16645  0
                     adaptor.addChild(root_1, expression452.getTree());
 16646  
 
 16647  
 
 16648  0
                     _last = (CommonTree)input.LT(1);
 16649  0
                     pushFollow(FOLLOW_expression_in_builtInCall3427);
 16650  0
                     expression453=expression();
 16651  
 
 16652  0
                     state._fsp--;
 16653  
 
 16654  0
                     adaptor.addChild(root_1, expression453.getTree());
 16655  
 
 16656  
 
 16657  0
                     match(input, Token.UP, null); 
 16658  0
                     adaptor.addChild(root_0, root_1);
 16659  0
                     _last = _save_last_1;
 16660  
                     }
 16661  
 
 16662  
 
 16663  
                     }
 16664  0
                     break;
 16665  
                 case 26 :
 16666  
                     // com\\googlecode\\sparkleg\\SparqlT.g:478:7: ^( REPLACE expression expression expression )
 16667  
                     {
 16668  0
                     root_0 = (CommonTree)adaptor.nil();
 16669  
 
 16670  
 
 16671  0
                     _last = (CommonTree)input.LT(1);
 16672  
                     {
 16673  0
                     CommonTree _save_last_1 = _last;
 16674  0
                     CommonTree _first_1 = null;
 16675  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 16676  0
                     _last = (CommonTree)input.LT(1);
 16677  0
                     REPLACE454=(CommonTree)match(input,REPLACE,FOLLOW_REPLACE_in_builtInCall3437); 
 16678  0
                     REPLACE454_tree = (CommonTree)adaptor.dupNode(REPLACE454);
 16679  
 
 16680  
 
 16681  0
                     root_1 = (CommonTree)adaptor.becomeRoot(REPLACE454_tree, root_1);
 16682  
 
 16683  
 
 16684  0
                     match(input, Token.DOWN, null); 
 16685  0
                     _last = (CommonTree)input.LT(1);
 16686  0
                     pushFollow(FOLLOW_expression_in_builtInCall3439);
 16687  0
                     expression455=expression();
 16688  
 
 16689  0
                     state._fsp--;
 16690  
 
 16691  0
                     adaptor.addChild(root_1, expression455.getTree());
 16692  
 
 16693  
 
 16694  0
                     _last = (CommonTree)input.LT(1);
 16695  0
                     pushFollow(FOLLOW_expression_in_builtInCall3441);
 16696  0
                     expression456=expression();
 16697  
 
 16698  0
                     state._fsp--;
 16699  
 
 16700  0
                     adaptor.addChild(root_1, expression456.getTree());
 16701  
 
 16702  
 
 16703  0
                     _last = (CommonTree)input.LT(1);
 16704  0
                     pushFollow(FOLLOW_expression_in_builtInCall3443);
 16705  0
                     expression457=expression();
 16706  
 
 16707  0
                     state._fsp--;
 16708  
 
 16709  0
                     adaptor.addChild(root_1, expression457.getTree());
 16710  
 
 16711  
 
 16712  0
                     match(input, Token.UP, null); 
 16713  0
                     adaptor.addChild(root_0, root_1);
 16714  0
                     _last = _save_last_1;
 16715  
                     }
 16716  
 
 16717  
 
 16718  
                     }
 16719  0
                     break;
 16720  
                 case 27 :
 16721  
                     // com\\googlecode\\sparkleg\\SparqlT.g:479:7: ^( YEAR expression )
 16722  
                     {
 16723  0
                     root_0 = (CommonTree)adaptor.nil();
 16724  
 
 16725  
 
 16726  0
                     _last = (CommonTree)input.LT(1);
 16727  
                     {
 16728  0
                     CommonTree _save_last_1 = _last;
 16729  0
                     CommonTree _first_1 = null;
 16730  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 16731  0
                     _last = (CommonTree)input.LT(1);
 16732  0
                     YEAR458=(CommonTree)match(input,YEAR,FOLLOW_YEAR_in_builtInCall3453); 
 16733  0
                     YEAR458_tree = (CommonTree)adaptor.dupNode(YEAR458);
 16734  
 
 16735  
 
 16736  0
                     root_1 = (CommonTree)adaptor.becomeRoot(YEAR458_tree, root_1);
 16737  
 
 16738  
 
 16739  0
                     match(input, Token.DOWN, null); 
 16740  0
                     _last = (CommonTree)input.LT(1);
 16741  0
                     pushFollow(FOLLOW_expression_in_builtInCall3455);
 16742  0
                     expression459=expression();
 16743  
 
 16744  0
                     state._fsp--;
 16745  
 
 16746  0
                     adaptor.addChild(root_1, expression459.getTree());
 16747  
 
 16748  
 
 16749  0
                     match(input, Token.UP, null); 
 16750  0
                     adaptor.addChild(root_0, root_1);
 16751  0
                     _last = _save_last_1;
 16752  
                     }
 16753  
 
 16754  
 
 16755  
                     }
 16756  0
                     break;
 16757  
                 case 28 :
 16758  
                     // com\\googlecode\\sparkleg\\SparqlT.g:480:7: ^( MONTH expression )
 16759  
                     {
 16760  0
                     root_0 = (CommonTree)adaptor.nil();
 16761  
 
 16762  
 
 16763  0
                     _last = (CommonTree)input.LT(1);
 16764  
                     {
 16765  0
                     CommonTree _save_last_1 = _last;
 16766  0
                     CommonTree _first_1 = null;
 16767  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 16768  0
                     _last = (CommonTree)input.LT(1);
 16769  0
                     MONTH460=(CommonTree)match(input,MONTH,FOLLOW_MONTH_in_builtInCall3465); 
 16770  0
                     MONTH460_tree = (CommonTree)adaptor.dupNode(MONTH460);
 16771  
 
 16772  
 
 16773  0
                     root_1 = (CommonTree)adaptor.becomeRoot(MONTH460_tree, root_1);
 16774  
 
 16775  
 
 16776  0
                     match(input, Token.DOWN, null); 
 16777  0
                     _last = (CommonTree)input.LT(1);
 16778  0
                     pushFollow(FOLLOW_expression_in_builtInCall3467);
 16779  0
                     expression461=expression();
 16780  
 
 16781  0
                     state._fsp--;
 16782  
 
 16783  0
                     adaptor.addChild(root_1, expression461.getTree());
 16784  
 
 16785  
 
 16786  0
                     match(input, Token.UP, null); 
 16787  0
                     adaptor.addChild(root_0, root_1);
 16788  0
                     _last = _save_last_1;
 16789  
                     }
 16790  
 
 16791  
 
 16792  
                     }
 16793  0
                     break;
 16794  
                 case 29 :
 16795  
                     // com\\googlecode\\sparkleg\\SparqlT.g:481:7: ^( DAY expression )
 16796  
                     {
 16797  0
                     root_0 = (CommonTree)adaptor.nil();
 16798  
 
 16799  
 
 16800  0
                     _last = (CommonTree)input.LT(1);
 16801  
                     {
 16802  0
                     CommonTree _save_last_1 = _last;
 16803  0
                     CommonTree _first_1 = null;
 16804  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 16805  0
                     _last = (CommonTree)input.LT(1);
 16806  0
                     DAY462=(CommonTree)match(input,DAY,FOLLOW_DAY_in_builtInCall3477); 
 16807  0
                     DAY462_tree = (CommonTree)adaptor.dupNode(DAY462);
 16808  
 
 16809  
 
 16810  0
                     root_1 = (CommonTree)adaptor.becomeRoot(DAY462_tree, root_1);
 16811  
 
 16812  
 
 16813  0
                     match(input, Token.DOWN, null); 
 16814  0
                     _last = (CommonTree)input.LT(1);
 16815  0
                     pushFollow(FOLLOW_expression_in_builtInCall3479);
 16816  0
                     expression463=expression();
 16817  
 
 16818  0
                     state._fsp--;
 16819  
 
 16820  0
                     adaptor.addChild(root_1, expression463.getTree());
 16821  
 
 16822  
 
 16823  0
                     match(input, Token.UP, null); 
 16824  0
                     adaptor.addChild(root_0, root_1);
 16825  0
                     _last = _save_last_1;
 16826  
                     }
 16827  
 
 16828  
 
 16829  
                     }
 16830  0
                     break;
 16831  
                 case 30 :
 16832  
                     // com\\googlecode\\sparkleg\\SparqlT.g:482:7: ^( HOURS expression )
 16833  
                     {
 16834  0
                     root_0 = (CommonTree)adaptor.nil();
 16835  
 
 16836  
 
 16837  0
                     _last = (CommonTree)input.LT(1);
 16838  
                     {
 16839  0
                     CommonTree _save_last_1 = _last;
 16840  0
                     CommonTree _first_1 = null;
 16841  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 16842  0
                     _last = (CommonTree)input.LT(1);
 16843  0
                     HOURS464=(CommonTree)match(input,HOURS,FOLLOW_HOURS_in_builtInCall3489); 
 16844  0
                     HOURS464_tree = (CommonTree)adaptor.dupNode(HOURS464);
 16845  
 
 16846  
 
 16847  0
                     root_1 = (CommonTree)adaptor.becomeRoot(HOURS464_tree, root_1);
 16848  
 
 16849  
 
 16850  0
                     match(input, Token.DOWN, null); 
 16851  0
                     _last = (CommonTree)input.LT(1);
 16852  0
                     pushFollow(FOLLOW_expression_in_builtInCall3491);
 16853  0
                     expression465=expression();
 16854  
 
 16855  0
                     state._fsp--;
 16856  
 
 16857  0
                     adaptor.addChild(root_1, expression465.getTree());
 16858  
 
 16859  
 
 16860  0
                     match(input, Token.UP, null); 
 16861  0
                     adaptor.addChild(root_0, root_1);
 16862  0
                     _last = _save_last_1;
 16863  
                     }
 16864  
 
 16865  
 
 16866  
                     }
 16867  0
                     break;
 16868  
                 case 31 :
 16869  
                     // com\\googlecode\\sparkleg\\SparqlT.g:483:7: ^( MINUTES expression )
 16870  
                     {
 16871  0
                     root_0 = (CommonTree)adaptor.nil();
 16872  
 
 16873  
 
 16874  0
                     _last = (CommonTree)input.LT(1);
 16875  
                     {
 16876  0
                     CommonTree _save_last_1 = _last;
 16877  0
                     CommonTree _first_1 = null;
 16878  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 16879  0
                     _last = (CommonTree)input.LT(1);
 16880  0
                     MINUTES466=(CommonTree)match(input,MINUTES,FOLLOW_MINUTES_in_builtInCall3501); 
 16881  0
                     MINUTES466_tree = (CommonTree)adaptor.dupNode(MINUTES466);
 16882  
 
 16883  
 
 16884  0
                     root_1 = (CommonTree)adaptor.becomeRoot(MINUTES466_tree, root_1);
 16885  
 
 16886  
 
 16887  0
                     match(input, Token.DOWN, null); 
 16888  0
                     _last = (CommonTree)input.LT(1);
 16889  0
                     pushFollow(FOLLOW_expression_in_builtInCall3503);
 16890  0
                     expression467=expression();
 16891  
 
 16892  0
                     state._fsp--;
 16893  
 
 16894  0
                     adaptor.addChild(root_1, expression467.getTree());
 16895  
 
 16896  
 
 16897  0
                     match(input, Token.UP, null); 
 16898  0
                     adaptor.addChild(root_0, root_1);
 16899  0
                     _last = _save_last_1;
 16900  
                     }
 16901  
 
 16902  
 
 16903  
                     }
 16904  0
                     break;
 16905  
                 case 32 :
 16906  
                     // com\\googlecode\\sparkleg\\SparqlT.g:484:7: ^( SECONDS expression )
 16907  
                     {
 16908  0
                     root_0 = (CommonTree)adaptor.nil();
 16909  
 
 16910  
 
 16911  0
                     _last = (CommonTree)input.LT(1);
 16912  
                     {
 16913  0
                     CommonTree _save_last_1 = _last;
 16914  0
                     CommonTree _first_1 = null;
 16915  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 16916  0
                     _last = (CommonTree)input.LT(1);
 16917  0
                     SECONDS468=(CommonTree)match(input,SECONDS,FOLLOW_SECONDS_in_builtInCall3513); 
 16918  0
                     SECONDS468_tree = (CommonTree)adaptor.dupNode(SECONDS468);
 16919  
 
 16920  
 
 16921  0
                     root_1 = (CommonTree)adaptor.becomeRoot(SECONDS468_tree, root_1);
 16922  
 
 16923  
 
 16924  0
                     match(input, Token.DOWN, null); 
 16925  0
                     _last = (CommonTree)input.LT(1);
 16926  0
                     pushFollow(FOLLOW_expression_in_builtInCall3515);
 16927  0
                     expression469=expression();
 16928  
 
 16929  0
                     state._fsp--;
 16930  
 
 16931  0
                     adaptor.addChild(root_1, expression469.getTree());
 16932  
 
 16933  
 
 16934  0
                     match(input, Token.UP, null); 
 16935  0
                     adaptor.addChild(root_0, root_1);
 16936  0
                     _last = _save_last_1;
 16937  
                     }
 16938  
 
 16939  
 
 16940  
                     }
 16941  0
                     break;
 16942  
                 case 33 :
 16943  
                     // com\\googlecode\\sparkleg\\SparqlT.g:485:7: ^( TIMEZONE expression )
 16944  
                     {
 16945  0
                     root_0 = (CommonTree)adaptor.nil();
 16946  
 
 16947  
 
 16948  0
                     _last = (CommonTree)input.LT(1);
 16949  
                     {
 16950  0
                     CommonTree _save_last_1 = _last;
 16951  0
                     CommonTree _first_1 = null;
 16952  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 16953  0
                     _last = (CommonTree)input.LT(1);
 16954  0
                     TIMEZONE470=(CommonTree)match(input,TIMEZONE,FOLLOW_TIMEZONE_in_builtInCall3525); 
 16955  0
                     TIMEZONE470_tree = (CommonTree)adaptor.dupNode(TIMEZONE470);
 16956  
 
 16957  
 
 16958  0
                     root_1 = (CommonTree)adaptor.becomeRoot(TIMEZONE470_tree, root_1);
 16959  
 
 16960  
 
 16961  0
                     match(input, Token.DOWN, null); 
 16962  0
                     _last = (CommonTree)input.LT(1);
 16963  0
                     pushFollow(FOLLOW_expression_in_builtInCall3527);
 16964  0
                     expression471=expression();
 16965  
 
 16966  0
                     state._fsp--;
 16967  
 
 16968  0
                     adaptor.addChild(root_1, expression471.getTree());
 16969  
 
 16970  
 
 16971  0
                     match(input, Token.UP, null); 
 16972  0
                     adaptor.addChild(root_0, root_1);
 16973  0
                     _last = _save_last_1;
 16974  
                     }
 16975  
 
 16976  
 
 16977  
                     }
 16978  0
                     break;
 16979  
                 case 34 :
 16980  
                     // com\\googlecode\\sparkleg\\SparqlT.g:486:7: ^( TZ expression )
 16981  
                     {
 16982  0
                     root_0 = (CommonTree)adaptor.nil();
 16983  
 
 16984  
 
 16985  0
                     _last = (CommonTree)input.LT(1);
 16986  
                     {
 16987  0
                     CommonTree _save_last_1 = _last;
 16988  0
                     CommonTree _first_1 = null;
 16989  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 16990  0
                     _last = (CommonTree)input.LT(1);
 16991  0
                     TZ472=(CommonTree)match(input,TZ,FOLLOW_TZ_in_builtInCall3537); 
 16992  0
                     TZ472_tree = (CommonTree)adaptor.dupNode(TZ472);
 16993  
 
 16994  
 
 16995  0
                     root_1 = (CommonTree)adaptor.becomeRoot(TZ472_tree, root_1);
 16996  
 
 16997  
 
 16998  0
                     match(input, Token.DOWN, null); 
 16999  0
                     _last = (CommonTree)input.LT(1);
 17000  0
                     pushFollow(FOLLOW_expression_in_builtInCall3539);
 17001  0
                     expression473=expression();
 17002  
 
 17003  0
                     state._fsp--;
 17004  
 
 17005  0
                     adaptor.addChild(root_1, expression473.getTree());
 17006  
 
 17007  
 
 17008  0
                     match(input, Token.UP, null); 
 17009  0
                     adaptor.addChild(root_0, root_1);
 17010  0
                     _last = _save_last_1;
 17011  
                     }
 17012  
 
 17013  
 
 17014  
                     }
 17015  0
                     break;
 17016  
                 case 35 :
 17017  
                     // com\\googlecode\\sparkleg\\SparqlT.g:487:7: NOW
 17018  
                     {
 17019  0
                     root_0 = (CommonTree)adaptor.nil();
 17020  
 
 17021  
 
 17022  0
                     _last = (CommonTree)input.LT(1);
 17023  0
                     NOW474=(CommonTree)match(input,NOW,FOLLOW_NOW_in_builtInCall3548); 
 17024  0
                     NOW474_tree = (CommonTree)adaptor.dupNode(NOW474);
 17025  
 
 17026  
 
 17027  0
                     adaptor.addChild(root_0, NOW474_tree);
 17028  
 
 17029  
 
 17030  
                     }
 17031  0
                     break;
 17032  
                 case 36 :
 17033  
                     // com\\googlecode\\sparkleg\\SparqlT.g:488:7: ^( MD5 expression )
 17034  
                     {
 17035  0
                     root_0 = (CommonTree)adaptor.nil();
 17036  
 
 17037  
 
 17038  0
                     _last = (CommonTree)input.LT(1);
 17039  
                     {
 17040  0
                     CommonTree _save_last_1 = _last;
 17041  0
                     CommonTree _first_1 = null;
 17042  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 17043  0
                     _last = (CommonTree)input.LT(1);
 17044  0
                     MD5475=(CommonTree)match(input,MD5,FOLLOW_MD5_in_builtInCall3557); 
 17045  0
                     MD5475_tree = (CommonTree)adaptor.dupNode(MD5475);
 17046  
 
 17047  
 
 17048  0
                     root_1 = (CommonTree)adaptor.becomeRoot(MD5475_tree, root_1);
 17049  
 
 17050  
 
 17051  0
                     match(input, Token.DOWN, null); 
 17052  0
                     _last = (CommonTree)input.LT(1);
 17053  0
                     pushFollow(FOLLOW_expression_in_builtInCall3559);
 17054  0
                     expression476=expression();
 17055  
 
 17056  0
                     state._fsp--;
 17057  
 
 17058  0
                     adaptor.addChild(root_1, expression476.getTree());
 17059  
 
 17060  
 
 17061  0
                     match(input, Token.UP, null); 
 17062  0
                     adaptor.addChild(root_0, root_1);
 17063  0
                     _last = _save_last_1;
 17064  
                     }
 17065  
 
 17066  
 
 17067  
                     }
 17068  0
                     break;
 17069  
                 case 37 :
 17070  
                     // com\\googlecode\\sparkleg\\SparqlT.g:489:7: ^( SHA1 expression )
 17071  
                     {
 17072  0
                     root_0 = (CommonTree)adaptor.nil();
 17073  
 
 17074  
 
 17075  0
                     _last = (CommonTree)input.LT(1);
 17076  
                     {
 17077  0
                     CommonTree _save_last_1 = _last;
 17078  0
                     CommonTree _first_1 = null;
 17079  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 17080  0
                     _last = (CommonTree)input.LT(1);
 17081  0
                     SHA1477=(CommonTree)match(input,SHA1,FOLLOW_SHA1_in_builtInCall3569); 
 17082  0
                     SHA1477_tree = (CommonTree)adaptor.dupNode(SHA1477);
 17083  
 
 17084  
 
 17085  0
                     root_1 = (CommonTree)adaptor.becomeRoot(SHA1477_tree, root_1);
 17086  
 
 17087  
 
 17088  0
                     match(input, Token.DOWN, null); 
 17089  0
                     _last = (CommonTree)input.LT(1);
 17090  0
                     pushFollow(FOLLOW_expression_in_builtInCall3571);
 17091  0
                     expression478=expression();
 17092  
 
 17093  0
                     state._fsp--;
 17094  
 
 17095  0
                     adaptor.addChild(root_1, expression478.getTree());
 17096  
 
 17097  
 
 17098  0
                     match(input, Token.UP, null); 
 17099  0
                     adaptor.addChild(root_0, root_1);
 17100  0
                     _last = _save_last_1;
 17101  
                     }
 17102  
 
 17103  
 
 17104  
                     }
 17105  0
                     break;
 17106  
                 case 38 :
 17107  
                     // com\\googlecode\\sparkleg\\SparqlT.g:490:7: ^( SHA224 expression )
 17108  
                     {
 17109  0
                     root_0 = (CommonTree)adaptor.nil();
 17110  
 
 17111  
 
 17112  0
                     _last = (CommonTree)input.LT(1);
 17113  
                     {
 17114  0
                     CommonTree _save_last_1 = _last;
 17115  0
                     CommonTree _first_1 = null;
 17116  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 17117  0
                     _last = (CommonTree)input.LT(1);
 17118  0
                     SHA224479=(CommonTree)match(input,SHA224,FOLLOW_SHA224_in_builtInCall3581); 
 17119  0
                     SHA224479_tree = (CommonTree)adaptor.dupNode(SHA224479);
 17120  
 
 17121  
 
 17122  0
                     root_1 = (CommonTree)adaptor.becomeRoot(SHA224479_tree, root_1);
 17123  
 
 17124  
 
 17125  0
                     match(input, Token.DOWN, null); 
 17126  0
                     _last = (CommonTree)input.LT(1);
 17127  0
                     pushFollow(FOLLOW_expression_in_builtInCall3583);
 17128  0
                     expression480=expression();
 17129  
 
 17130  0
                     state._fsp--;
 17131  
 
 17132  0
                     adaptor.addChild(root_1, expression480.getTree());
 17133  
 
 17134  
 
 17135  0
                     match(input, Token.UP, null); 
 17136  0
                     adaptor.addChild(root_0, root_1);
 17137  0
                     _last = _save_last_1;
 17138  
                     }
 17139  
 
 17140  
 
 17141  
                     }
 17142  0
                     break;
 17143  
                 case 39 :
 17144  
                     // com\\googlecode\\sparkleg\\SparqlT.g:491:7: ^( SHA256 expression )
 17145  
                     {
 17146  0
                     root_0 = (CommonTree)adaptor.nil();
 17147  
 
 17148  
 
 17149  0
                     _last = (CommonTree)input.LT(1);
 17150  
                     {
 17151  0
                     CommonTree _save_last_1 = _last;
 17152  0
                     CommonTree _first_1 = null;
 17153  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 17154  0
                     _last = (CommonTree)input.LT(1);
 17155  0
                     SHA256481=(CommonTree)match(input,SHA256,FOLLOW_SHA256_in_builtInCall3593); 
 17156  0
                     SHA256481_tree = (CommonTree)adaptor.dupNode(SHA256481);
 17157  
 
 17158  
 
 17159  0
                     root_1 = (CommonTree)adaptor.becomeRoot(SHA256481_tree, root_1);
 17160  
 
 17161  
 
 17162  0
                     match(input, Token.DOWN, null); 
 17163  0
                     _last = (CommonTree)input.LT(1);
 17164  0
                     pushFollow(FOLLOW_expression_in_builtInCall3595);
 17165  0
                     expression482=expression();
 17166  
 
 17167  0
                     state._fsp--;
 17168  
 
 17169  0
                     adaptor.addChild(root_1, expression482.getTree());
 17170  
 
 17171  
 
 17172  0
                     match(input, Token.UP, null); 
 17173  0
                     adaptor.addChild(root_0, root_1);
 17174  0
                     _last = _save_last_1;
 17175  
                     }
 17176  
 
 17177  
 
 17178  
                     }
 17179  0
                     break;
 17180  
                 case 40 :
 17181  
                     // com\\googlecode\\sparkleg\\SparqlT.g:492:7: ^( SHA384 expression )
 17182  
                     {
 17183  0
                     root_0 = (CommonTree)adaptor.nil();
 17184  
 
 17185  
 
 17186  0
                     _last = (CommonTree)input.LT(1);
 17187  
                     {
 17188  0
                     CommonTree _save_last_1 = _last;
 17189  0
                     CommonTree _first_1 = null;
 17190  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 17191  0
                     _last = (CommonTree)input.LT(1);
 17192  0
                     SHA384483=(CommonTree)match(input,SHA384,FOLLOW_SHA384_in_builtInCall3605); 
 17193  0
                     SHA384483_tree = (CommonTree)adaptor.dupNode(SHA384483);
 17194  
 
 17195  
 
 17196  0
                     root_1 = (CommonTree)adaptor.becomeRoot(SHA384483_tree, root_1);
 17197  
 
 17198  
 
 17199  0
                     match(input, Token.DOWN, null); 
 17200  0
                     _last = (CommonTree)input.LT(1);
 17201  0
                     pushFollow(FOLLOW_expression_in_builtInCall3607);
 17202  0
                     expression484=expression();
 17203  
 
 17204  0
                     state._fsp--;
 17205  
 
 17206  0
                     adaptor.addChild(root_1, expression484.getTree());
 17207  
 
 17208  
 
 17209  0
                     match(input, Token.UP, null); 
 17210  0
                     adaptor.addChild(root_0, root_1);
 17211  0
                     _last = _save_last_1;
 17212  
                     }
 17213  
 
 17214  
 
 17215  
                     }
 17216  0
                     break;
 17217  
                 case 41 :
 17218  
                     // com\\googlecode\\sparkleg\\SparqlT.g:493:7: ^( SHA512 expression )
 17219  
                     {
 17220  0
                     root_0 = (CommonTree)adaptor.nil();
 17221  
 
 17222  
 
 17223  0
                     _last = (CommonTree)input.LT(1);
 17224  
                     {
 17225  0
                     CommonTree _save_last_1 = _last;
 17226  0
                     CommonTree _first_1 = null;
 17227  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 17228  0
                     _last = (CommonTree)input.LT(1);
 17229  0
                     SHA512485=(CommonTree)match(input,SHA512,FOLLOW_SHA512_in_builtInCall3617); 
 17230  0
                     SHA512485_tree = (CommonTree)adaptor.dupNode(SHA512485);
 17231  
 
 17232  
 
 17233  0
                     root_1 = (CommonTree)adaptor.becomeRoot(SHA512485_tree, root_1);
 17234  
 
 17235  
 
 17236  0
                     match(input, Token.DOWN, null); 
 17237  0
                     _last = (CommonTree)input.LT(1);
 17238  0
                     pushFollow(FOLLOW_expression_in_builtInCall3619);
 17239  0
                     expression486=expression();
 17240  
 
 17241  0
                     state._fsp--;
 17242  
 
 17243  0
                     adaptor.addChild(root_1, expression486.getTree());
 17244  
 
 17245  
 
 17246  0
                     match(input, Token.UP, null); 
 17247  0
                     adaptor.addChild(root_0, root_1);
 17248  0
                     _last = _save_last_1;
 17249  
                     }
 17250  
 
 17251  
 
 17252  
                     }
 17253  0
                     break;
 17254  
                 case 42 :
 17255  
                     // com\\googlecode\\sparkleg\\SparqlT.g:494:7: ^( COALESCE expressionList )
 17256  
                     {
 17257  0
                     root_0 = (CommonTree)adaptor.nil();
 17258  
 
 17259  
 
 17260  0
                     _last = (CommonTree)input.LT(1);
 17261  
                     {
 17262  0
                     CommonTree _save_last_1 = _last;
 17263  0
                     CommonTree _first_1 = null;
 17264  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 17265  0
                     _last = (CommonTree)input.LT(1);
 17266  0
                     COALESCE487=(CommonTree)match(input,COALESCE,FOLLOW_COALESCE_in_builtInCall3629); 
 17267  0
                     COALESCE487_tree = (CommonTree)adaptor.dupNode(COALESCE487);
 17268  
 
 17269  
 
 17270  0
                     root_1 = (CommonTree)adaptor.becomeRoot(COALESCE487_tree, root_1);
 17271  
 
 17272  
 
 17273  0
                     match(input, Token.DOWN, null); 
 17274  0
                     _last = (CommonTree)input.LT(1);
 17275  0
                     pushFollow(FOLLOW_expressionList_in_builtInCall3631);
 17276  0
                     expressionList488=expressionList();
 17277  
 
 17278  0
                     state._fsp--;
 17279  
 
 17280  0
                     adaptor.addChild(root_1, expressionList488.getTree());
 17281  
 
 17282  
 
 17283  0
                     match(input, Token.UP, null); 
 17284  0
                     adaptor.addChild(root_0, root_1);
 17285  0
                     _last = _save_last_1;
 17286  
                     }
 17287  
 
 17288  
 
 17289  
                     }
 17290  0
                     break;
 17291  
                 case 43 :
 17292  
                     // com\\googlecode\\sparkleg\\SparqlT.g:495:7: ^( IF expression expression expression )
 17293  
                     {
 17294  0
                     root_0 = (CommonTree)adaptor.nil();
 17295  
 
 17296  
 
 17297  0
                     _last = (CommonTree)input.LT(1);
 17298  
                     {
 17299  0
                     CommonTree _save_last_1 = _last;
 17300  0
                     CommonTree _first_1 = null;
 17301  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 17302  0
                     _last = (CommonTree)input.LT(1);
 17303  0
                     IF489=(CommonTree)match(input,IF,FOLLOW_IF_in_builtInCall3641); 
 17304  0
                     IF489_tree = (CommonTree)adaptor.dupNode(IF489);
 17305  
 
 17306  
 
 17307  0
                     root_1 = (CommonTree)adaptor.becomeRoot(IF489_tree, root_1);
 17308  
 
 17309  
 
 17310  0
                     match(input, Token.DOWN, null); 
 17311  0
                     _last = (CommonTree)input.LT(1);
 17312  0
                     pushFollow(FOLLOW_expression_in_builtInCall3643);
 17313  0
                     expression490=expression();
 17314  
 
 17315  0
                     state._fsp--;
 17316  
 
 17317  0
                     adaptor.addChild(root_1, expression490.getTree());
 17318  
 
 17319  
 
 17320  0
                     _last = (CommonTree)input.LT(1);
 17321  0
                     pushFollow(FOLLOW_expression_in_builtInCall3645);
 17322  0
                     expression491=expression();
 17323  
 
 17324  0
                     state._fsp--;
 17325  
 
 17326  0
                     adaptor.addChild(root_1, expression491.getTree());
 17327  
 
 17328  
 
 17329  0
                     _last = (CommonTree)input.LT(1);
 17330  0
                     pushFollow(FOLLOW_expression_in_builtInCall3647);
 17331  0
                     expression492=expression();
 17332  
 
 17333  0
                     state._fsp--;
 17334  
 
 17335  0
                     adaptor.addChild(root_1, expression492.getTree());
 17336  
 
 17337  
 
 17338  0
                     match(input, Token.UP, null); 
 17339  0
                     adaptor.addChild(root_0, root_1);
 17340  0
                     _last = _save_last_1;
 17341  
                     }
 17342  
 
 17343  
 
 17344  
                     }
 17345  0
                     break;
 17346  
                 case 44 :
 17347  
                     // com\\googlecode\\sparkleg\\SparqlT.g:496:7: ^( STRLANG expression expression )
 17348  
                     {
 17349  0
                     root_0 = (CommonTree)adaptor.nil();
 17350  
 
 17351  
 
 17352  0
                     _last = (CommonTree)input.LT(1);
 17353  
                     {
 17354  0
                     CommonTree _save_last_1 = _last;
 17355  0
                     CommonTree _first_1 = null;
 17356  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 17357  0
                     _last = (CommonTree)input.LT(1);
 17358  0
                     STRLANG493=(CommonTree)match(input,STRLANG,FOLLOW_STRLANG_in_builtInCall3657); 
 17359  0
                     STRLANG493_tree = (CommonTree)adaptor.dupNode(STRLANG493);
 17360  
 
 17361  
 
 17362  0
                     root_1 = (CommonTree)adaptor.becomeRoot(STRLANG493_tree, root_1);
 17363  
 
 17364  
 
 17365  0
                     match(input, Token.DOWN, null); 
 17366  0
                     _last = (CommonTree)input.LT(1);
 17367  0
                     pushFollow(FOLLOW_expression_in_builtInCall3659);
 17368  0
                     expression494=expression();
 17369  
 
 17370  0
                     state._fsp--;
 17371  
 
 17372  0
                     adaptor.addChild(root_1, expression494.getTree());
 17373  
 
 17374  
 
 17375  0
                     _last = (CommonTree)input.LT(1);
 17376  0
                     pushFollow(FOLLOW_expression_in_builtInCall3661);
 17377  0
                     expression495=expression();
 17378  
 
 17379  0
                     state._fsp--;
 17380  
 
 17381  0
                     adaptor.addChild(root_1, expression495.getTree());
 17382  
 
 17383  
 
 17384  0
                     match(input, Token.UP, null); 
 17385  0
                     adaptor.addChild(root_0, root_1);
 17386  0
                     _last = _save_last_1;
 17387  
                     }
 17388  
 
 17389  
 
 17390  
                     }
 17391  0
                     break;
 17392  
                 case 45 :
 17393  
                     // com\\googlecode\\sparkleg\\SparqlT.g:497:7: ^( STRDT expression expression )
 17394  
                     {
 17395  0
                     root_0 = (CommonTree)adaptor.nil();
 17396  
 
 17397  
 
 17398  0
                     _last = (CommonTree)input.LT(1);
 17399  
                     {
 17400  0
                     CommonTree _save_last_1 = _last;
 17401  0
                     CommonTree _first_1 = null;
 17402  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 17403  0
                     _last = (CommonTree)input.LT(1);
 17404  0
                     STRDT496=(CommonTree)match(input,STRDT,FOLLOW_STRDT_in_builtInCall3671); 
 17405  0
                     STRDT496_tree = (CommonTree)adaptor.dupNode(STRDT496);
 17406  
 
 17407  
 
 17408  0
                     root_1 = (CommonTree)adaptor.becomeRoot(STRDT496_tree, root_1);
 17409  
 
 17410  
 
 17411  0
                     match(input, Token.DOWN, null); 
 17412  0
                     _last = (CommonTree)input.LT(1);
 17413  0
                     pushFollow(FOLLOW_expression_in_builtInCall3673);
 17414  0
                     expression497=expression();
 17415  
 
 17416  0
                     state._fsp--;
 17417  
 
 17418  0
                     adaptor.addChild(root_1, expression497.getTree());
 17419  
 
 17420  
 
 17421  0
                     _last = (CommonTree)input.LT(1);
 17422  0
                     pushFollow(FOLLOW_expression_in_builtInCall3675);
 17423  0
                     expression498=expression();
 17424  
 
 17425  0
                     state._fsp--;
 17426  
 
 17427  0
                     adaptor.addChild(root_1, expression498.getTree());
 17428  
 
 17429  
 
 17430  0
                     match(input, Token.UP, null); 
 17431  0
                     adaptor.addChild(root_0, root_1);
 17432  0
                     _last = _save_last_1;
 17433  
                     }
 17434  
 
 17435  
 
 17436  
                     }
 17437  0
                     break;
 17438  
                 case 46 :
 17439  
                     // com\\googlecode\\sparkleg\\SparqlT.g:498:7: ^( SAMETERM expression expression )
 17440  
                     {
 17441  0
                     root_0 = (CommonTree)adaptor.nil();
 17442  
 
 17443  
 
 17444  0
                     _last = (CommonTree)input.LT(1);
 17445  
                     {
 17446  0
                     CommonTree _save_last_1 = _last;
 17447  0
                     CommonTree _first_1 = null;
 17448  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 17449  0
                     _last = (CommonTree)input.LT(1);
 17450  0
                     SAMETERM499=(CommonTree)match(input,SAMETERM,FOLLOW_SAMETERM_in_builtInCall3685); 
 17451  0
                     SAMETERM499_tree = (CommonTree)adaptor.dupNode(SAMETERM499);
 17452  
 
 17453  
 
 17454  0
                     root_1 = (CommonTree)adaptor.becomeRoot(SAMETERM499_tree, root_1);
 17455  
 
 17456  
 
 17457  0
                     match(input, Token.DOWN, null); 
 17458  0
                     _last = (CommonTree)input.LT(1);
 17459  0
                     pushFollow(FOLLOW_expression_in_builtInCall3687);
 17460  0
                     expression500=expression();
 17461  
 
 17462  0
                     state._fsp--;
 17463  
 
 17464  0
                     adaptor.addChild(root_1, expression500.getTree());
 17465  
 
 17466  
 
 17467  0
                     _last = (CommonTree)input.LT(1);
 17468  0
                     pushFollow(FOLLOW_expression_in_builtInCall3689);
 17469  0
                     expression501=expression();
 17470  
 
 17471  0
                     state._fsp--;
 17472  
 
 17473  0
                     adaptor.addChild(root_1, expression501.getTree());
 17474  
 
 17475  
 
 17476  0
                     match(input, Token.UP, null); 
 17477  0
                     adaptor.addChild(root_0, root_1);
 17478  0
                     _last = _save_last_1;
 17479  
                     }
 17480  
 
 17481  
 
 17482  
                     }
 17483  0
                     break;
 17484  
                 case 47 :
 17485  
                     // com\\googlecode\\sparkleg\\SparqlT.g:499:7: ^( ISIRI expression )
 17486  
                     {
 17487  0
                     root_0 = (CommonTree)adaptor.nil();
 17488  
 
 17489  
 
 17490  0
                     _last = (CommonTree)input.LT(1);
 17491  
                     {
 17492  0
                     CommonTree _save_last_1 = _last;
 17493  0
                     CommonTree _first_1 = null;
 17494  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 17495  0
                     _last = (CommonTree)input.LT(1);
 17496  0
                     ISIRI502=(CommonTree)match(input,ISIRI,FOLLOW_ISIRI_in_builtInCall3699); 
 17497  0
                     ISIRI502_tree = (CommonTree)adaptor.dupNode(ISIRI502);
 17498  
 
 17499  
 
 17500  0
                     root_1 = (CommonTree)adaptor.becomeRoot(ISIRI502_tree, root_1);
 17501  
 
 17502  
 
 17503  0
                     match(input, Token.DOWN, null); 
 17504  0
                     _last = (CommonTree)input.LT(1);
 17505  0
                     pushFollow(FOLLOW_expression_in_builtInCall3701);
 17506  0
                     expression503=expression();
 17507  
 
 17508  0
                     state._fsp--;
 17509  
 
 17510  0
                     adaptor.addChild(root_1, expression503.getTree());
 17511  
 
 17512  
 
 17513  0
                     match(input, Token.UP, null); 
 17514  0
                     adaptor.addChild(root_0, root_1);
 17515  0
                     _last = _save_last_1;
 17516  
                     }
 17517  
 
 17518  
 
 17519  
                     }
 17520  0
                     break;
 17521  
                 case 48 :
 17522  
                     // com\\googlecode\\sparkleg\\SparqlT.g:500:7: ^( ISURI expression )
 17523  
                     {
 17524  0
                     root_0 = (CommonTree)adaptor.nil();
 17525  
 
 17526  
 
 17527  0
                     _last = (CommonTree)input.LT(1);
 17528  
                     {
 17529  0
                     CommonTree _save_last_1 = _last;
 17530  0
                     CommonTree _first_1 = null;
 17531  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 17532  0
                     _last = (CommonTree)input.LT(1);
 17533  0
                     ISURI504=(CommonTree)match(input,ISURI,FOLLOW_ISURI_in_builtInCall3711); 
 17534  0
                     ISURI504_tree = (CommonTree)adaptor.dupNode(ISURI504);
 17535  
 
 17536  
 
 17537  0
                     root_1 = (CommonTree)adaptor.becomeRoot(ISURI504_tree, root_1);
 17538  
 
 17539  
 
 17540  0
                     match(input, Token.DOWN, null); 
 17541  0
                     _last = (CommonTree)input.LT(1);
 17542  0
                     pushFollow(FOLLOW_expression_in_builtInCall3713);
 17543  0
                     expression505=expression();
 17544  
 
 17545  0
                     state._fsp--;
 17546  
 
 17547  0
                     adaptor.addChild(root_1, expression505.getTree());
 17548  
 
 17549  
 
 17550  0
                     match(input, Token.UP, null); 
 17551  0
                     adaptor.addChild(root_0, root_1);
 17552  0
                     _last = _save_last_1;
 17553  
                     }
 17554  
 
 17555  
 
 17556  
                     }
 17557  0
                     break;
 17558  
                 case 49 :
 17559  
                     // com\\googlecode\\sparkleg\\SparqlT.g:501:7: ^( ISBLANK expression )
 17560  
                     {
 17561  0
                     root_0 = (CommonTree)adaptor.nil();
 17562  
 
 17563  
 
 17564  0
                     _last = (CommonTree)input.LT(1);
 17565  
                     {
 17566  0
                     CommonTree _save_last_1 = _last;
 17567  0
                     CommonTree _first_1 = null;
 17568  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 17569  0
                     _last = (CommonTree)input.LT(1);
 17570  0
                     ISBLANK506=(CommonTree)match(input,ISBLANK,FOLLOW_ISBLANK_in_builtInCall3723); 
 17571  0
                     ISBLANK506_tree = (CommonTree)adaptor.dupNode(ISBLANK506);
 17572  
 
 17573  
 
 17574  0
                     root_1 = (CommonTree)adaptor.becomeRoot(ISBLANK506_tree, root_1);
 17575  
 
 17576  
 
 17577  0
                     match(input, Token.DOWN, null); 
 17578  0
                     _last = (CommonTree)input.LT(1);
 17579  0
                     pushFollow(FOLLOW_expression_in_builtInCall3725);
 17580  0
                     expression507=expression();
 17581  
 
 17582  0
                     state._fsp--;
 17583  
 
 17584  0
                     adaptor.addChild(root_1, expression507.getTree());
 17585  
 
 17586  
 
 17587  0
                     match(input, Token.UP, null); 
 17588  0
                     adaptor.addChild(root_0, root_1);
 17589  0
                     _last = _save_last_1;
 17590  
                     }
 17591  
 
 17592  
 
 17593  
                     }
 17594  0
                     break;
 17595  
                 case 50 :
 17596  
                     // com\\googlecode\\sparkleg\\SparqlT.g:502:7: ^( ISLITERAL expression )
 17597  
                     {
 17598  0
                     root_0 = (CommonTree)adaptor.nil();
 17599  
 
 17600  
 
 17601  0
                     _last = (CommonTree)input.LT(1);
 17602  
                     {
 17603  0
                     CommonTree _save_last_1 = _last;
 17604  0
                     CommonTree _first_1 = null;
 17605  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 17606  0
                     _last = (CommonTree)input.LT(1);
 17607  0
                     ISLITERAL508=(CommonTree)match(input,ISLITERAL,FOLLOW_ISLITERAL_in_builtInCall3736); 
 17608  0
                     ISLITERAL508_tree = (CommonTree)adaptor.dupNode(ISLITERAL508);
 17609  
 
 17610  
 
 17611  0
                     root_1 = (CommonTree)adaptor.becomeRoot(ISLITERAL508_tree, root_1);
 17612  
 
 17613  
 
 17614  0
                     match(input, Token.DOWN, null); 
 17615  0
                     _last = (CommonTree)input.LT(1);
 17616  0
                     pushFollow(FOLLOW_expression_in_builtInCall3738);
 17617  0
                     expression509=expression();
 17618  
 
 17619  0
                     state._fsp--;
 17620  
 
 17621  0
                     adaptor.addChild(root_1, expression509.getTree());
 17622  
 
 17623  
 
 17624  0
                     match(input, Token.UP, null); 
 17625  0
                     adaptor.addChild(root_0, root_1);
 17626  0
                     _last = _save_last_1;
 17627  
                     }
 17628  
 
 17629  
 
 17630  
                     }
 17631  0
                     break;
 17632  
                 case 51 :
 17633  
                     // com\\googlecode\\sparkleg\\SparqlT.g:503:7: ^( ISNUMERIC expression )
 17634  
                     {
 17635  0
                     root_0 = (CommonTree)adaptor.nil();
 17636  
 
 17637  
 
 17638  0
                     _last = (CommonTree)input.LT(1);
 17639  
                     {
 17640  0
                     CommonTree _save_last_1 = _last;
 17641  0
                     CommonTree _first_1 = null;
 17642  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 17643  0
                     _last = (CommonTree)input.LT(1);
 17644  0
                     ISNUMERIC510=(CommonTree)match(input,ISNUMERIC,FOLLOW_ISNUMERIC_in_builtInCall3748); 
 17645  0
                     ISNUMERIC510_tree = (CommonTree)adaptor.dupNode(ISNUMERIC510);
 17646  
 
 17647  
 
 17648  0
                     root_1 = (CommonTree)adaptor.becomeRoot(ISNUMERIC510_tree, root_1);
 17649  
 
 17650  
 
 17651  0
                     match(input, Token.DOWN, null); 
 17652  0
                     _last = (CommonTree)input.LT(1);
 17653  0
                     pushFollow(FOLLOW_expression_in_builtInCall3750);
 17654  0
                     expression511=expression();
 17655  
 
 17656  0
                     state._fsp--;
 17657  
 
 17658  0
                     adaptor.addChild(root_1, expression511.getTree());
 17659  
 
 17660  
 
 17661  0
                     match(input, Token.UP, null); 
 17662  0
                     adaptor.addChild(root_0, root_1);
 17663  0
                     _last = _save_last_1;
 17664  
                     }
 17665  
 
 17666  
 
 17667  
                     }
 17668  0
                     break;
 17669  
                 case 52 :
 17670  
                     // com\\googlecode\\sparkleg\\SparqlT.g:504:7: regexExpression
 17671  
                     {
 17672  0
                     root_0 = (CommonTree)adaptor.nil();
 17673  
 
 17674  
 
 17675  0
                     _last = (CommonTree)input.LT(1);
 17676  0
                     pushFollow(FOLLOW_regexExpression_in_builtInCall3759);
 17677  0
                     regexExpression512=regexExpression();
 17678  
 
 17679  0
                     state._fsp--;
 17680  
 
 17681  0
                     adaptor.addChild(root_0, regexExpression512.getTree());
 17682  
 
 17683  
 
 17684  
                     }
 17685  0
                     break;
 17686  
                 case 53 :
 17687  
                     // com\\googlecode\\sparkleg\\SparqlT.g:505:7: existsFunction
 17688  
                     {
 17689  0
                     root_0 = (CommonTree)adaptor.nil();
 17690  
 
 17691  
 
 17692  0
                     _last = (CommonTree)input.LT(1);
 17693  0
                     pushFollow(FOLLOW_existsFunction_in_builtInCall3767);
 17694  0
                     existsFunction513=existsFunction();
 17695  
 
 17696  0
                     state._fsp--;
 17697  
 
 17698  0
                     adaptor.addChild(root_0, existsFunction513.getTree());
 17699  
 
 17700  
 
 17701  
                     }
 17702  0
                     break;
 17703  
                 case 54 :
 17704  
                     // com\\googlecode\\sparkleg\\SparqlT.g:506:7: notExistsFunction
 17705  
                     {
 17706  0
                     root_0 = (CommonTree)adaptor.nil();
 17707  
 
 17708  
 
 17709  0
                     _last = (CommonTree)input.LT(1);
 17710  0
                     pushFollow(FOLLOW_notExistsFunction_in_builtInCall3775);
 17711  0
                     notExistsFunction514=notExistsFunction();
 17712  
 
 17713  0
                     state._fsp--;
 17714  
 
 17715  0
                     adaptor.addChild(root_0, notExistsFunction514.getTree());
 17716  
 
 17717  
 
 17718  
                     }
 17719  
                     break;
 17720  
 
 17721  
             }
 17722  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 17723  
 
 17724  
         }
 17725  0
         catch (RecognitionException re) {
 17726  0
             reportError(re);
 17727  0
             recover(input,re);
 17728  
         }
 17729  
 
 17730  0
         finally {
 17731  
                 // do for sure before leaving
 17732  0
         }
 17733  0
         return retval;
 17734  
     }
 17735  
     // $ANTLR end "builtInCall"
 17736  
 
 17737  
 
 17738  0
     public static class regexExpression_return extends TreeRuleReturnScope {
 17739  
         CommonTree tree;
 17740  0
         public Object getTree() { return tree; }
 17741  
     };
 17742  
 
 17743  
 
 17744  
     // $ANTLR start "regexExpression"
 17745  
     // com\\googlecode\\sparkleg\\SparqlT.g:509:1: regexExpression : ^( REGEX ( expression )+ ) ;
 17746  
     public final SparqlT.regexExpression_return regexExpression() throws RecognitionException {
 17747  0
         SparqlT.regexExpression_return retval = new SparqlT.regexExpression_return();
 17748  0
         retval.start = input.LT(1);
 17749  
 
 17750  
 
 17751  0
         CommonTree root_0 = null;
 17752  
 
 17753  0
         CommonTree _first_0 = null;
 17754  0
         CommonTree _last = null;
 17755  
 
 17756  0
         CommonTree REGEX515=null;
 17757  0
         SparqlT.expression_return expression516 =null;
 17758  
 
 17759  
 
 17760  0
         CommonTree REGEX515_tree=null;
 17761  
 
 17762  
         try {
 17763  
             // com\\googlecode\\sparkleg\\SparqlT.g:510:5: ( ^( REGEX ( expression )+ ) )
 17764  
             // com\\googlecode\\sparkleg\\SparqlT.g:510:7: ^( REGEX ( expression )+ )
 17765  
             {
 17766  0
             root_0 = (CommonTree)adaptor.nil();
 17767  
 
 17768  
 
 17769  0
             _last = (CommonTree)input.LT(1);
 17770  
             {
 17771  0
             CommonTree _save_last_1 = _last;
 17772  0
             CommonTree _first_1 = null;
 17773  0
             CommonTree root_1 = (CommonTree)adaptor.nil();
 17774  0
             _last = (CommonTree)input.LT(1);
 17775  0
             REGEX515=(CommonTree)match(input,REGEX,FOLLOW_REGEX_in_regexExpression3793); 
 17776  0
             REGEX515_tree = (CommonTree)adaptor.dupNode(REGEX515);
 17777  
 
 17778  
 
 17779  0
             root_1 = (CommonTree)adaptor.becomeRoot(REGEX515_tree, root_1);
 17780  
 
 17781  
 
 17782  0
             match(input, Token.DOWN, null); 
 17783  
             // com\\googlecode\\sparkleg\\SparqlT.g:510:15: ( expression )+
 17784  0
             int cnt131=0;
 17785  
             loop131:
 17786  
             do {
 17787  0
                 int alt131=2;
 17788  0
                 switch ( input.LA(1) ) {
 17789  
                 case AND:
 17790  
                 case ASTERISK:
 17791  
                 case DECIMAL_NEGATIVE:
 17792  
                 case DECIMAL_POSITIVE:
 17793  
                 case DIVIDE:
 17794  
                 case DOUBLE_NEGATIVE:
 17795  
                 case DOUBLE_POSITIVE:
 17796  
                 case EQUAL:
 17797  
                 case GREATER:
 17798  
                 case GREATER_EQUAL:
 17799  
                 case IN:
 17800  
                 case INTEGER_NEGATIVE:
 17801  
                 case INTEGER_POSITIVE:
 17802  
                 case LESS:
 17803  
                 case LESS_EQUAL:
 17804  
                 case MINUS:
 17805  
                 case NOT:
 17806  
                 case NOT_EQUAL:
 17807  
                 case OR:
 17808  
                 case PLUS:
 17809  
                 case UNARY:
 17810  
                     {
 17811  0
                     alt131=1;
 17812  
                     }
 17813  
                     break;
 17814  
 
 17815  
                 }
 17816  
 
 17817  0
                 switch (alt131) {
 17818  
                     case 1 :
 17819  
                         // com\\googlecode\\sparkleg\\SparqlT.g:510:15: expression
 17820  
                         {
 17821  0
                         _last = (CommonTree)input.LT(1);
 17822  0
                         pushFollow(FOLLOW_expression_in_regexExpression3795);
 17823  0
                         expression516=expression();
 17824  
 
 17825  0
                         state._fsp--;
 17826  
 
 17827  0
                         adaptor.addChild(root_1, expression516.getTree());
 17828  
 
 17829  
 
 17830  
                         }
 17831  0
                         break;
 17832  
 
 17833  
                     default :
 17834  0
                         if ( cnt131 >= 1 ) break loop131;
 17835  0
                         EarlyExitException eee =
 17836  
                             new EarlyExitException(131, input);
 17837  0
                         throw eee;
 17838  
                 }
 17839  0
                 cnt131++;
 17840  0
             } while (true);
 17841  
 
 17842  
 
 17843  0
             match(input, Token.UP, null); 
 17844  0
             adaptor.addChild(root_0, root_1);
 17845  0
             _last = _save_last_1;
 17846  
             }
 17847  
 
 17848  
 
 17849  
             }
 17850  
 
 17851  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 17852  
 
 17853  
         }
 17854  0
         catch (RecognitionException re) {
 17855  0
             reportError(re);
 17856  0
             recover(input,re);
 17857  
         }
 17858  
 
 17859  0
         finally {
 17860  
                 // do for sure before leaving
 17861  0
         }
 17862  0
         return retval;
 17863  
     }
 17864  
     // $ANTLR end "regexExpression"
 17865  
 
 17866  
 
 17867  0
     public static class subStringExpression_return extends TreeRuleReturnScope {
 17868  
         CommonTree tree;
 17869  0
         public Object getTree() { return tree; }
 17870  
     };
 17871  
 
 17872  
 
 17873  
     // $ANTLR start "subStringExpression"
 17874  
     // com\\googlecode\\sparkleg\\SparqlT.g:513:1: subStringExpression : ^( SUBSTR ( expression )+ ) ;
 17875  
     public final SparqlT.subStringExpression_return subStringExpression() throws RecognitionException {
 17876  0
         SparqlT.subStringExpression_return retval = new SparqlT.subStringExpression_return();
 17877  0
         retval.start = input.LT(1);
 17878  
 
 17879  
 
 17880  0
         CommonTree root_0 = null;
 17881  
 
 17882  0
         CommonTree _first_0 = null;
 17883  0
         CommonTree _last = null;
 17884  
 
 17885  0
         CommonTree SUBSTR517=null;
 17886  0
         SparqlT.expression_return expression518 =null;
 17887  
 
 17888  
 
 17889  0
         CommonTree SUBSTR517_tree=null;
 17890  
 
 17891  
         try {
 17892  
             // com\\googlecode\\sparkleg\\SparqlT.g:514:5: ( ^( SUBSTR ( expression )+ ) )
 17893  
             // com\\googlecode\\sparkleg\\SparqlT.g:514:7: ^( SUBSTR ( expression )+ )
 17894  
             {
 17895  0
             root_0 = (CommonTree)adaptor.nil();
 17896  
 
 17897  
 
 17898  0
             _last = (CommonTree)input.LT(1);
 17899  
             {
 17900  0
             CommonTree _save_last_1 = _last;
 17901  0
             CommonTree _first_1 = null;
 17902  0
             CommonTree root_1 = (CommonTree)adaptor.nil();
 17903  0
             _last = (CommonTree)input.LT(1);
 17904  0
             SUBSTR517=(CommonTree)match(input,SUBSTR,FOLLOW_SUBSTR_in_subStringExpression3819); 
 17905  0
             SUBSTR517_tree = (CommonTree)adaptor.dupNode(SUBSTR517);
 17906  
 
 17907  
 
 17908  0
             root_1 = (CommonTree)adaptor.becomeRoot(SUBSTR517_tree, root_1);
 17909  
 
 17910  
 
 17911  0
             match(input, Token.DOWN, null); 
 17912  
             // com\\googlecode\\sparkleg\\SparqlT.g:514:16: ( expression )+
 17913  0
             int cnt132=0;
 17914  
             loop132:
 17915  
             do {
 17916  0
                 int alt132=2;
 17917  0
                 switch ( input.LA(1) ) {
 17918  
                 case AND:
 17919  
                 case ASTERISK:
 17920  
                 case DECIMAL_NEGATIVE:
 17921  
                 case DECIMAL_POSITIVE:
 17922  
                 case DIVIDE:
 17923  
                 case DOUBLE_NEGATIVE:
 17924  
                 case DOUBLE_POSITIVE:
 17925  
                 case EQUAL:
 17926  
                 case GREATER:
 17927  
                 case GREATER_EQUAL:
 17928  
                 case IN:
 17929  
                 case INTEGER_NEGATIVE:
 17930  
                 case INTEGER_POSITIVE:
 17931  
                 case LESS:
 17932  
                 case LESS_EQUAL:
 17933  
                 case MINUS:
 17934  
                 case NOT:
 17935  
                 case NOT_EQUAL:
 17936  
                 case OR:
 17937  
                 case PLUS:
 17938  
                 case UNARY:
 17939  
                     {
 17940  0
                     alt132=1;
 17941  
                     }
 17942  
                     break;
 17943  
 
 17944  
                 }
 17945  
 
 17946  0
                 switch (alt132) {
 17947  
                     case 1 :
 17948  
                         // com\\googlecode\\sparkleg\\SparqlT.g:514:16: expression
 17949  
                         {
 17950  0
                         _last = (CommonTree)input.LT(1);
 17951  0
                         pushFollow(FOLLOW_expression_in_subStringExpression3821);
 17952  0
                         expression518=expression();
 17953  
 
 17954  0
                         state._fsp--;
 17955  
 
 17956  0
                         adaptor.addChild(root_1, expression518.getTree());
 17957  
 
 17958  
 
 17959  
                         }
 17960  0
                         break;
 17961  
 
 17962  
                     default :
 17963  0
                         if ( cnt132 >= 1 ) break loop132;
 17964  0
                         EarlyExitException eee =
 17965  
                             new EarlyExitException(132, input);
 17966  0
                         throw eee;
 17967  
                 }
 17968  0
                 cnt132++;
 17969  0
             } while (true);
 17970  
 
 17971  
 
 17972  0
             match(input, Token.UP, null); 
 17973  0
             adaptor.addChild(root_0, root_1);
 17974  0
             _last = _save_last_1;
 17975  
             }
 17976  
 
 17977  
 
 17978  
             }
 17979  
 
 17980  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 17981  
 
 17982  
         }
 17983  0
         catch (RecognitionException re) {
 17984  0
             reportError(re);
 17985  0
             recover(input,re);
 17986  
         }
 17987  
 
 17988  0
         finally {
 17989  
                 // do for sure before leaving
 17990  0
         }
 17991  0
         return retval;
 17992  
     }
 17993  
     // $ANTLR end "subStringExpression"
 17994  
 
 17995  
 
 17996  0
     public static class existsFunction_return extends TreeRuleReturnScope {
 17997  
         CommonTree tree;
 17998  0
         public Object getTree() { return tree; }
 17999  
     };
 18000  
 
 18001  
 
 18002  
     // $ANTLR start "existsFunction"
 18003  
     // com\\googlecode\\sparkleg\\SparqlT.g:517:1: existsFunction : ^( EXISTS groupGraphPattern ) ;
 18004  
     public final SparqlT.existsFunction_return existsFunction() throws RecognitionException {
 18005  0
         SparqlT.existsFunction_return retval = new SparqlT.existsFunction_return();
 18006  0
         retval.start = input.LT(1);
 18007  
 
 18008  
 
 18009  0
         CommonTree root_0 = null;
 18010  
 
 18011  0
         CommonTree _first_0 = null;
 18012  0
         CommonTree _last = null;
 18013  
 
 18014  0
         CommonTree EXISTS519=null;
 18015  0
         SparqlT.groupGraphPattern_return groupGraphPattern520 =null;
 18016  
 
 18017  
 
 18018  0
         CommonTree EXISTS519_tree=null;
 18019  
 
 18020  
         try {
 18021  
             // com\\googlecode\\sparkleg\\SparqlT.g:518:5: ( ^( EXISTS groupGraphPattern ) )
 18022  
             // com\\googlecode\\sparkleg\\SparqlT.g:518:7: ^( EXISTS groupGraphPattern )
 18023  
             {
 18024  0
             root_0 = (CommonTree)adaptor.nil();
 18025  
 
 18026  
 
 18027  0
             _last = (CommonTree)input.LT(1);
 18028  
             {
 18029  0
             CommonTree _save_last_1 = _last;
 18030  0
             CommonTree _first_1 = null;
 18031  0
             CommonTree root_1 = (CommonTree)adaptor.nil();
 18032  0
             _last = (CommonTree)input.LT(1);
 18033  0
             EXISTS519=(CommonTree)match(input,EXISTS,FOLLOW_EXISTS_in_existsFunction3845); 
 18034  0
             EXISTS519_tree = (CommonTree)adaptor.dupNode(EXISTS519);
 18035  
 
 18036  
 
 18037  0
             root_1 = (CommonTree)adaptor.becomeRoot(EXISTS519_tree, root_1);
 18038  
 
 18039  
 
 18040  0
             match(input, Token.DOWN, null); 
 18041  0
             _last = (CommonTree)input.LT(1);
 18042  0
             pushFollow(FOLLOW_groupGraphPattern_in_existsFunction3847);
 18043  0
             groupGraphPattern520=groupGraphPattern();
 18044  
 
 18045  0
             state._fsp--;
 18046  
 
 18047  0
             adaptor.addChild(root_1, groupGraphPattern520.getTree());
 18048  
 
 18049  
 
 18050  0
             match(input, Token.UP, null); 
 18051  0
             adaptor.addChild(root_0, root_1);
 18052  0
             _last = _save_last_1;
 18053  
             }
 18054  
 
 18055  
 
 18056  
             }
 18057  
 
 18058  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 18059  
 
 18060  
         }
 18061  0
         catch (RecognitionException re) {
 18062  0
             reportError(re);
 18063  0
             recover(input,re);
 18064  
         }
 18065  
 
 18066  0
         finally {
 18067  
                 // do for sure before leaving
 18068  0
         }
 18069  0
         return retval;
 18070  
     }
 18071  
     // $ANTLR end "existsFunction"
 18072  
 
 18073  
 
 18074  0
     public static class notExistsFunction_return extends TreeRuleReturnScope {
 18075  
         CommonTree tree;
 18076  0
         public Object getTree() { return tree; }
 18077  
     };
 18078  
 
 18079  
 
 18080  
     // $ANTLR start "notExistsFunction"
 18081  
     // com\\googlecode\\sparkleg\\SparqlT.g:521:1: notExistsFunction : ^( NOT_EXISTS groupGraphPattern ) ;
 18082  
     public final SparqlT.notExistsFunction_return notExistsFunction() throws RecognitionException {
 18083  0
         SparqlT.notExistsFunction_return retval = new SparqlT.notExistsFunction_return();
 18084  0
         retval.start = input.LT(1);
 18085  
 
 18086  
 
 18087  0
         CommonTree root_0 = null;
 18088  
 
 18089  0
         CommonTree _first_0 = null;
 18090  0
         CommonTree _last = null;
 18091  
 
 18092  0
         CommonTree NOT_EXISTS521=null;
 18093  0
         SparqlT.groupGraphPattern_return groupGraphPattern522 =null;
 18094  
 
 18095  
 
 18096  0
         CommonTree NOT_EXISTS521_tree=null;
 18097  
 
 18098  
         try {
 18099  
             // com\\googlecode\\sparkleg\\SparqlT.g:522:5: ( ^( NOT_EXISTS groupGraphPattern ) )
 18100  
             // com\\googlecode\\sparkleg\\SparqlT.g:522:7: ^( NOT_EXISTS groupGraphPattern )
 18101  
             {
 18102  0
             root_0 = (CommonTree)adaptor.nil();
 18103  
 
 18104  
 
 18105  0
             _last = (CommonTree)input.LT(1);
 18106  
             {
 18107  0
             CommonTree _save_last_1 = _last;
 18108  0
             CommonTree _first_1 = null;
 18109  0
             CommonTree root_1 = (CommonTree)adaptor.nil();
 18110  0
             _last = (CommonTree)input.LT(1);
 18111  0
             NOT_EXISTS521=(CommonTree)match(input,NOT_EXISTS,FOLLOW_NOT_EXISTS_in_notExistsFunction3866); 
 18112  0
             NOT_EXISTS521_tree = (CommonTree)adaptor.dupNode(NOT_EXISTS521);
 18113  
 
 18114  
 
 18115  0
             root_1 = (CommonTree)adaptor.becomeRoot(NOT_EXISTS521_tree, root_1);
 18116  
 
 18117  
 
 18118  0
             match(input, Token.DOWN, null); 
 18119  0
             _last = (CommonTree)input.LT(1);
 18120  0
             pushFollow(FOLLOW_groupGraphPattern_in_notExistsFunction3868);
 18121  0
             groupGraphPattern522=groupGraphPattern();
 18122  
 
 18123  0
             state._fsp--;
 18124  
 
 18125  0
             adaptor.addChild(root_1, groupGraphPattern522.getTree());
 18126  
 
 18127  
 
 18128  0
             match(input, Token.UP, null); 
 18129  0
             adaptor.addChild(root_0, root_1);
 18130  0
             _last = _save_last_1;
 18131  
             }
 18132  
 
 18133  
 
 18134  
             }
 18135  
 
 18136  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 18137  
 
 18138  
         }
 18139  0
         catch (RecognitionException re) {
 18140  0
             reportError(re);
 18141  0
             recover(input,re);
 18142  
         }
 18143  
 
 18144  0
         finally {
 18145  
                 // do for sure before leaving
 18146  0
         }
 18147  0
         return retval;
 18148  
     }
 18149  
     // $ANTLR end "notExistsFunction"
 18150  
 
 18151  
 
 18152  0
     public static class aggregate_return extends TreeRuleReturnScope {
 18153  
         CommonTree tree;
 18154  0
         public Object getTree() { return tree; }
 18155  
     };
 18156  
 
 18157  
 
 18158  
     // $ANTLR start "aggregate"
 18159  
     // com\\googlecode\\sparkleg\\SparqlT.g:525:1: aggregate : ( ^( COUNT ( DISTINCT )* ( ASTERISK )* ( expression )* ) | ^( SUM ( DISTINCT )* expression ) | ^( MIN ( DISTINCT )* expression ) | ^( MAX ( DISTINCT )* expression ) | ^( AVG ( DISTINCT )* expression ) | ^( SAMPLE ( DISTINCT )? expression ) | ^( GROUP_CONCAT ( DISTINCT )* expression ( string )? ) );
 18160  
     public final SparqlT.aggregate_return aggregate() throws RecognitionException {
 18161  0
         SparqlT.aggregate_return retval = new SparqlT.aggregate_return();
 18162  0
         retval.start = input.LT(1);
 18163  
 
 18164  
 
 18165  0
         CommonTree root_0 = null;
 18166  
 
 18167  0
         CommonTree _first_0 = null;
 18168  0
         CommonTree _last = null;
 18169  
 
 18170  0
         CommonTree COUNT523=null;
 18171  0
         CommonTree DISTINCT524=null;
 18172  0
         CommonTree ASTERISK525=null;
 18173  0
         CommonTree SUM527=null;
 18174  0
         CommonTree DISTINCT528=null;
 18175  0
         CommonTree MIN530=null;
 18176  0
         CommonTree DISTINCT531=null;
 18177  0
         CommonTree MAX533=null;
 18178  0
         CommonTree DISTINCT534=null;
 18179  0
         CommonTree AVG536=null;
 18180  0
         CommonTree DISTINCT537=null;
 18181  0
         CommonTree SAMPLE539=null;
 18182  0
         CommonTree DISTINCT540=null;
 18183  0
         CommonTree GROUP_CONCAT542=null;
 18184  0
         CommonTree DISTINCT543=null;
 18185  0
         SparqlT.expression_return expression526 =null;
 18186  
 
 18187  0
         SparqlT.expression_return expression529 =null;
 18188  
 
 18189  0
         SparqlT.expression_return expression532 =null;
 18190  
 
 18191  0
         SparqlT.expression_return expression535 =null;
 18192  
 
 18193  0
         SparqlT.expression_return expression538 =null;
 18194  
 
 18195  0
         SparqlT.expression_return expression541 =null;
 18196  
 
 18197  0
         SparqlT.expression_return expression544 =null;
 18198  
 
 18199  0
         SparqlT.string_return string545 =null;
 18200  
 
 18201  
 
 18202  0
         CommonTree COUNT523_tree=null;
 18203  0
         CommonTree DISTINCT524_tree=null;
 18204  0
         CommonTree ASTERISK525_tree=null;
 18205  0
         CommonTree SUM527_tree=null;
 18206  0
         CommonTree DISTINCT528_tree=null;
 18207  0
         CommonTree MIN530_tree=null;
 18208  0
         CommonTree DISTINCT531_tree=null;
 18209  0
         CommonTree MAX533_tree=null;
 18210  0
         CommonTree DISTINCT534_tree=null;
 18211  0
         CommonTree AVG536_tree=null;
 18212  0
         CommonTree DISTINCT537_tree=null;
 18213  0
         CommonTree SAMPLE539_tree=null;
 18214  0
         CommonTree DISTINCT540_tree=null;
 18215  0
         CommonTree GROUP_CONCAT542_tree=null;
 18216  0
         CommonTree DISTINCT543_tree=null;
 18217  
 
 18218  
         try {
 18219  
             // com\\googlecode\\sparkleg\\SparqlT.g:526:5: ( ^( COUNT ( DISTINCT )* ( ASTERISK )* ( expression )* ) | ^( SUM ( DISTINCT )* expression ) | ^( MIN ( DISTINCT )* expression ) | ^( MAX ( DISTINCT )* expression ) | ^( AVG ( DISTINCT )* expression ) | ^( SAMPLE ( DISTINCT )? expression ) | ^( GROUP_CONCAT ( DISTINCT )* expression ( string )? ) )
 18220  0
             int alt143=7;
 18221  0
             switch ( input.LA(1) ) {
 18222  
             case COUNT:
 18223  
                 {
 18224  0
                 alt143=1;
 18225  
                 }
 18226  0
                 break;
 18227  
             case SUM:
 18228  
                 {
 18229  0
                 alt143=2;
 18230  
                 }
 18231  0
                 break;
 18232  
             case MIN:
 18233  
                 {
 18234  0
                 alt143=3;
 18235  
                 }
 18236  0
                 break;
 18237  
             case MAX:
 18238  
                 {
 18239  0
                 alt143=4;
 18240  
                 }
 18241  0
                 break;
 18242  
             case AVG:
 18243  
                 {
 18244  0
                 alt143=5;
 18245  
                 }
 18246  0
                 break;
 18247  
             case SAMPLE:
 18248  
                 {
 18249  0
                 alt143=6;
 18250  
                 }
 18251  0
                 break;
 18252  
             case GROUP_CONCAT:
 18253  
                 {
 18254  0
                 alt143=7;
 18255  
                 }
 18256  0
                 break;
 18257  
             default:
 18258  0
                 NoViableAltException nvae =
 18259  
                     new NoViableAltException("", 143, 0, input);
 18260  
 
 18261  0
                 throw nvae;
 18262  
 
 18263  
             }
 18264  
 
 18265  0
             switch (alt143) {
 18266  
                 case 1 :
 18267  
                     // com\\googlecode\\sparkleg\\SparqlT.g:526:7: ^( COUNT ( DISTINCT )* ( ASTERISK )* ( expression )* )
 18268  
                     {
 18269  0
                     root_0 = (CommonTree)adaptor.nil();
 18270  
 
 18271  
 
 18272  0
                     _last = (CommonTree)input.LT(1);
 18273  
                     {
 18274  0
                     CommonTree _save_last_1 = _last;
 18275  0
                     CommonTree _first_1 = null;
 18276  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 18277  0
                     _last = (CommonTree)input.LT(1);
 18278  0
                     COUNT523=(CommonTree)match(input,COUNT,FOLLOW_COUNT_in_aggregate3887); 
 18279  0
                     COUNT523_tree = (CommonTree)adaptor.dupNode(COUNT523);
 18280  
 
 18281  
 
 18282  0
                     root_1 = (CommonTree)adaptor.becomeRoot(COUNT523_tree, root_1);
 18283  
 
 18284  
 
 18285  0
                     if ( input.LA(1)==Token.DOWN ) {
 18286  0
                         match(input, Token.DOWN, null); 
 18287  
                         // com\\googlecode\\sparkleg\\SparqlT.g:526:15: ( DISTINCT )*
 18288  
                         loop133:
 18289  
                         do {
 18290  0
                             int alt133=2;
 18291  0
                             switch ( input.LA(1) ) {
 18292  
                             case DISTINCT:
 18293  
                                 {
 18294  0
                                 alt133=1;
 18295  
                                 }
 18296  
                                 break;
 18297  
 
 18298  
                             }
 18299  
 
 18300  0
                             switch (alt133) {
 18301  
                                 case 1 :
 18302  
                                     // com\\googlecode\\sparkleg\\SparqlT.g:526:15: DISTINCT
 18303  
                                     {
 18304  0
                                     _last = (CommonTree)input.LT(1);
 18305  0
                                     DISTINCT524=(CommonTree)match(input,DISTINCT,FOLLOW_DISTINCT_in_aggregate3889); 
 18306  0
                                     DISTINCT524_tree = (CommonTree)adaptor.dupNode(DISTINCT524);
 18307  
 
 18308  
 
 18309  0
                                     adaptor.addChild(root_1, DISTINCT524_tree);
 18310  
 
 18311  
 
 18312  
                                     }
 18313  0
                                     break;
 18314  
 
 18315  
                                 default :
 18316  0
                                     break loop133;
 18317  
                             }
 18318  0
                         } while (true);
 18319  
 
 18320  
 
 18321  
                         // com\\googlecode\\sparkleg\\SparqlT.g:526:25: ( ASTERISK )*
 18322  
                         loop134:
 18323  
                         do {
 18324  0
                             int alt134=2;
 18325  0
                             switch ( input.LA(1) ) {
 18326  
                             case ASTERISK:
 18327  
                                 {
 18328  0
                                 switch ( input.LA(2) ) {
 18329  
                                 case UP:
 18330  
                                 case AND:
 18331  
                                 case ASTERISK:
 18332  
                                 case DECIMAL_NEGATIVE:
 18333  
                                 case DECIMAL_POSITIVE:
 18334  
                                 case DIVIDE:
 18335  
                                 case DOUBLE_NEGATIVE:
 18336  
                                 case DOUBLE_POSITIVE:
 18337  
                                 case EQUAL:
 18338  
                                 case GREATER:
 18339  
                                 case GREATER_EQUAL:
 18340  
                                 case IN:
 18341  
                                 case INTEGER_NEGATIVE:
 18342  
                                 case INTEGER_POSITIVE:
 18343  
                                 case LESS:
 18344  
                                 case LESS_EQUAL:
 18345  
                                 case MINUS:
 18346  
                                 case NOT:
 18347  
                                 case NOT_EQUAL:
 18348  
                                 case OR:
 18349  
                                 case PLUS:
 18350  
                                 case UNARY:
 18351  
                                     {
 18352  0
                                     alt134=1;
 18353  
                                     }
 18354  
                                     break;
 18355  
 
 18356  
                                 }
 18357  
 
 18358  
                                 }
 18359  
                                 break;
 18360  
 
 18361  
                             }
 18362  
 
 18363  0
                             switch (alt134) {
 18364  
                                 case 1 :
 18365  
                                     // com\\googlecode\\sparkleg\\SparqlT.g:526:25: ASTERISK
 18366  
                                     {
 18367  0
                                     _last = (CommonTree)input.LT(1);
 18368  0
                                     ASTERISK525=(CommonTree)match(input,ASTERISK,FOLLOW_ASTERISK_in_aggregate3892); 
 18369  0
                                     ASTERISK525_tree = (CommonTree)adaptor.dupNode(ASTERISK525);
 18370  
 
 18371  
 
 18372  0
                                     adaptor.addChild(root_1, ASTERISK525_tree);
 18373  
 
 18374  
 
 18375  
                                     }
 18376  0
                                     break;
 18377  
 
 18378  
                                 default :
 18379  0
                                     break loop134;
 18380  
                             }
 18381  0
                         } while (true);
 18382  
 
 18383  
 
 18384  
                         // com\\googlecode\\sparkleg\\SparqlT.g:526:35: ( expression )*
 18385  
                         loop135:
 18386  
                         do {
 18387  0
                             int alt135=2;
 18388  0
                             switch ( input.LA(1) ) {
 18389  
                             case AND:
 18390  
                             case ASTERISK:
 18391  
                             case DECIMAL_NEGATIVE:
 18392  
                             case DECIMAL_POSITIVE:
 18393  
                             case DIVIDE:
 18394  
                             case DOUBLE_NEGATIVE:
 18395  
                             case DOUBLE_POSITIVE:
 18396  
                             case EQUAL:
 18397  
                             case GREATER:
 18398  
                             case GREATER_EQUAL:
 18399  
                             case IN:
 18400  
                             case INTEGER_NEGATIVE:
 18401  
                             case INTEGER_POSITIVE:
 18402  
                             case LESS:
 18403  
                             case LESS_EQUAL:
 18404  
                             case MINUS:
 18405  
                             case NOT:
 18406  
                             case NOT_EQUAL:
 18407  
                             case OR:
 18408  
                             case PLUS:
 18409  
                             case UNARY:
 18410  
                                 {
 18411  0
                                 alt135=1;
 18412  
                                 }
 18413  
                                 break;
 18414  
 
 18415  
                             }
 18416  
 
 18417  0
                             switch (alt135) {
 18418  
                                 case 1 :
 18419  
                                     // com\\googlecode\\sparkleg\\SparqlT.g:526:35: expression
 18420  
                                     {
 18421  0
                                     _last = (CommonTree)input.LT(1);
 18422  0
                                     pushFollow(FOLLOW_expression_in_aggregate3895);
 18423  0
                                     expression526=expression();
 18424  
 
 18425  0
                                     state._fsp--;
 18426  
 
 18427  0
                                     adaptor.addChild(root_1, expression526.getTree());
 18428  
 
 18429  
 
 18430  
                                     }
 18431  0
                                     break;
 18432  
 
 18433  
                                 default :
 18434  0
                                     break loop135;
 18435  
                             }
 18436  0
                         } while (true);
 18437  
 
 18438  
 
 18439  0
                         match(input, Token.UP, null); 
 18440  
                     }
 18441  0
                     adaptor.addChild(root_0, root_1);
 18442  0
                     _last = _save_last_1;
 18443  
                     }
 18444  
 
 18445  
 
 18446  
                     }
 18447  0
                     break;
 18448  
                 case 2 :
 18449  
                     // com\\googlecode\\sparkleg\\SparqlT.g:527:7: ^( SUM ( DISTINCT )* expression )
 18450  
                     {
 18451  0
                     root_0 = (CommonTree)adaptor.nil();
 18452  
 
 18453  
 
 18454  0
                     _last = (CommonTree)input.LT(1);
 18455  
                     {
 18456  0
                     CommonTree _save_last_1 = _last;
 18457  0
                     CommonTree _first_1 = null;
 18458  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 18459  0
                     _last = (CommonTree)input.LT(1);
 18460  0
                     SUM527=(CommonTree)match(input,SUM,FOLLOW_SUM_in_aggregate3906); 
 18461  0
                     SUM527_tree = (CommonTree)adaptor.dupNode(SUM527);
 18462  
 
 18463  
 
 18464  0
                     root_1 = (CommonTree)adaptor.becomeRoot(SUM527_tree, root_1);
 18465  
 
 18466  
 
 18467  0
                     match(input, Token.DOWN, null); 
 18468  
                     // com\\googlecode\\sparkleg\\SparqlT.g:527:13: ( DISTINCT )*
 18469  
                     loop136:
 18470  
                     do {
 18471  0
                         int alt136=2;
 18472  0
                         switch ( input.LA(1) ) {
 18473  
                         case DISTINCT:
 18474  
                             {
 18475  0
                             alt136=1;
 18476  
                             }
 18477  
                             break;
 18478  
 
 18479  
                         }
 18480  
 
 18481  0
                         switch (alt136) {
 18482  
                             case 1 :
 18483  
                                 // com\\googlecode\\sparkleg\\SparqlT.g:527:13: DISTINCT
 18484  
                                 {
 18485  0
                                 _last = (CommonTree)input.LT(1);
 18486  0
                                 DISTINCT528=(CommonTree)match(input,DISTINCT,FOLLOW_DISTINCT_in_aggregate3908); 
 18487  0
                                 DISTINCT528_tree = (CommonTree)adaptor.dupNode(DISTINCT528);
 18488  
 
 18489  
 
 18490  0
                                 adaptor.addChild(root_1, DISTINCT528_tree);
 18491  
 
 18492  
 
 18493  
                                 }
 18494  0
                                 break;
 18495  
 
 18496  
                             default :
 18497  0
                                 break loop136;
 18498  
                         }
 18499  0
                     } while (true);
 18500  
 
 18501  
 
 18502  0
                     _last = (CommonTree)input.LT(1);
 18503  0
                     pushFollow(FOLLOW_expression_in_aggregate3911);
 18504  0
                     expression529=expression();
 18505  
 
 18506  0
                     state._fsp--;
 18507  
 
 18508  0
                     adaptor.addChild(root_1, expression529.getTree());
 18509  
 
 18510  
 
 18511  0
                     match(input, Token.UP, null); 
 18512  0
                     adaptor.addChild(root_0, root_1);
 18513  0
                     _last = _save_last_1;
 18514  
                     }
 18515  
 
 18516  
 
 18517  
                     }
 18518  0
                     break;
 18519  
                 case 3 :
 18520  
                     // com\\googlecode\\sparkleg\\SparqlT.g:528:7: ^( MIN ( DISTINCT )* expression )
 18521  
                     {
 18522  0
                     root_0 = (CommonTree)adaptor.nil();
 18523  
 
 18524  
 
 18525  0
                     _last = (CommonTree)input.LT(1);
 18526  
                     {
 18527  0
                     CommonTree _save_last_1 = _last;
 18528  0
                     CommonTree _first_1 = null;
 18529  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 18530  0
                     _last = (CommonTree)input.LT(1);
 18531  0
                     MIN530=(CommonTree)match(input,MIN,FOLLOW_MIN_in_aggregate3921); 
 18532  0
                     MIN530_tree = (CommonTree)adaptor.dupNode(MIN530);
 18533  
 
 18534  
 
 18535  0
                     root_1 = (CommonTree)adaptor.becomeRoot(MIN530_tree, root_1);
 18536  
 
 18537  
 
 18538  0
                     match(input, Token.DOWN, null); 
 18539  
                     // com\\googlecode\\sparkleg\\SparqlT.g:528:13: ( DISTINCT )*
 18540  
                     loop137:
 18541  
                     do {
 18542  0
                         int alt137=2;
 18543  0
                         switch ( input.LA(1) ) {
 18544  
                         case DISTINCT:
 18545  
                             {
 18546  0
                             alt137=1;
 18547  
                             }
 18548  
                             break;
 18549  
 
 18550  
                         }
 18551  
 
 18552  0
                         switch (alt137) {
 18553  
                             case 1 :
 18554  
                                 // com\\googlecode\\sparkleg\\SparqlT.g:528:13: DISTINCT
 18555  
                                 {
 18556  0
                                 _last = (CommonTree)input.LT(1);
 18557  0
                                 DISTINCT531=(CommonTree)match(input,DISTINCT,FOLLOW_DISTINCT_in_aggregate3923); 
 18558  0
                                 DISTINCT531_tree = (CommonTree)adaptor.dupNode(DISTINCT531);
 18559  
 
 18560  
 
 18561  0
                                 adaptor.addChild(root_1, DISTINCT531_tree);
 18562  
 
 18563  
 
 18564  
                                 }
 18565  0
                                 break;
 18566  
 
 18567  
                             default :
 18568  0
                                 break loop137;
 18569  
                         }
 18570  0
                     } while (true);
 18571  
 
 18572  
 
 18573  0
                     _last = (CommonTree)input.LT(1);
 18574  0
                     pushFollow(FOLLOW_expression_in_aggregate3926);
 18575  0
                     expression532=expression();
 18576  
 
 18577  0
                     state._fsp--;
 18578  
 
 18579  0
                     adaptor.addChild(root_1, expression532.getTree());
 18580  
 
 18581  
 
 18582  0
                     match(input, Token.UP, null); 
 18583  0
                     adaptor.addChild(root_0, root_1);
 18584  0
                     _last = _save_last_1;
 18585  
                     }
 18586  
 
 18587  
 
 18588  
                     }
 18589  0
                     break;
 18590  
                 case 4 :
 18591  
                     // com\\googlecode\\sparkleg\\SparqlT.g:529:7: ^( MAX ( DISTINCT )* expression )
 18592  
                     {
 18593  0
                     root_0 = (CommonTree)adaptor.nil();
 18594  
 
 18595  
 
 18596  0
                     _last = (CommonTree)input.LT(1);
 18597  
                     {
 18598  0
                     CommonTree _save_last_1 = _last;
 18599  0
                     CommonTree _first_1 = null;
 18600  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 18601  0
                     _last = (CommonTree)input.LT(1);
 18602  0
                     MAX533=(CommonTree)match(input,MAX,FOLLOW_MAX_in_aggregate3936); 
 18603  0
                     MAX533_tree = (CommonTree)adaptor.dupNode(MAX533);
 18604  
 
 18605  
 
 18606  0
                     root_1 = (CommonTree)adaptor.becomeRoot(MAX533_tree, root_1);
 18607  
 
 18608  
 
 18609  0
                     match(input, Token.DOWN, null); 
 18610  
                     // com\\googlecode\\sparkleg\\SparqlT.g:529:13: ( DISTINCT )*
 18611  
                     loop138:
 18612  
                     do {
 18613  0
                         int alt138=2;
 18614  0
                         switch ( input.LA(1) ) {
 18615  
                         case DISTINCT:
 18616  
                             {
 18617  0
                             alt138=1;
 18618  
                             }
 18619  
                             break;
 18620  
 
 18621  
                         }
 18622  
 
 18623  0
                         switch (alt138) {
 18624  
                             case 1 :
 18625  
                                 // com\\googlecode\\sparkleg\\SparqlT.g:529:13: DISTINCT
 18626  
                                 {
 18627  0
                                 _last = (CommonTree)input.LT(1);
 18628  0
                                 DISTINCT534=(CommonTree)match(input,DISTINCT,FOLLOW_DISTINCT_in_aggregate3938); 
 18629  0
                                 DISTINCT534_tree = (CommonTree)adaptor.dupNode(DISTINCT534);
 18630  
 
 18631  
 
 18632  0
                                 adaptor.addChild(root_1, DISTINCT534_tree);
 18633  
 
 18634  
 
 18635  
                                 }
 18636  0
                                 break;
 18637  
 
 18638  
                             default :
 18639  0
                                 break loop138;
 18640  
                         }
 18641  0
                     } while (true);
 18642  
 
 18643  
 
 18644  0
                     _last = (CommonTree)input.LT(1);
 18645  0
                     pushFollow(FOLLOW_expression_in_aggregate3941);
 18646  0
                     expression535=expression();
 18647  
 
 18648  0
                     state._fsp--;
 18649  
 
 18650  0
                     adaptor.addChild(root_1, expression535.getTree());
 18651  
 
 18652  
 
 18653  0
                     match(input, Token.UP, null); 
 18654  0
                     adaptor.addChild(root_0, root_1);
 18655  0
                     _last = _save_last_1;
 18656  
                     }
 18657  
 
 18658  
 
 18659  
                     }
 18660  0
                     break;
 18661  
                 case 5 :
 18662  
                     // com\\googlecode\\sparkleg\\SparqlT.g:530:7: ^( AVG ( DISTINCT )* expression )
 18663  
                     {
 18664  0
                     root_0 = (CommonTree)adaptor.nil();
 18665  
 
 18666  
 
 18667  0
                     _last = (CommonTree)input.LT(1);
 18668  
                     {
 18669  0
                     CommonTree _save_last_1 = _last;
 18670  0
                     CommonTree _first_1 = null;
 18671  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 18672  0
                     _last = (CommonTree)input.LT(1);
 18673  0
                     AVG536=(CommonTree)match(input,AVG,FOLLOW_AVG_in_aggregate3951); 
 18674  0
                     AVG536_tree = (CommonTree)adaptor.dupNode(AVG536);
 18675  
 
 18676  
 
 18677  0
                     root_1 = (CommonTree)adaptor.becomeRoot(AVG536_tree, root_1);
 18678  
 
 18679  
 
 18680  0
                     match(input, Token.DOWN, null); 
 18681  
                     // com\\googlecode\\sparkleg\\SparqlT.g:530:13: ( DISTINCT )*
 18682  
                     loop139:
 18683  
                     do {
 18684  0
                         int alt139=2;
 18685  0
                         switch ( input.LA(1) ) {
 18686  
                         case DISTINCT:
 18687  
                             {
 18688  0
                             alt139=1;
 18689  
                             }
 18690  
                             break;
 18691  
 
 18692  
                         }
 18693  
 
 18694  0
                         switch (alt139) {
 18695  
                             case 1 :
 18696  
                                 // com\\googlecode\\sparkleg\\SparqlT.g:530:13: DISTINCT
 18697  
                                 {
 18698  0
                                 _last = (CommonTree)input.LT(1);
 18699  0
                                 DISTINCT537=(CommonTree)match(input,DISTINCT,FOLLOW_DISTINCT_in_aggregate3953); 
 18700  0
                                 DISTINCT537_tree = (CommonTree)adaptor.dupNode(DISTINCT537);
 18701  
 
 18702  
 
 18703  0
                                 adaptor.addChild(root_1, DISTINCT537_tree);
 18704  
 
 18705  
 
 18706  
                                 }
 18707  0
                                 break;
 18708  
 
 18709  
                             default :
 18710  0
                                 break loop139;
 18711  
                         }
 18712  0
                     } while (true);
 18713  
 
 18714  
 
 18715  0
                     _last = (CommonTree)input.LT(1);
 18716  0
                     pushFollow(FOLLOW_expression_in_aggregate3956);
 18717  0
                     expression538=expression();
 18718  
 
 18719  0
                     state._fsp--;
 18720  
 
 18721  0
                     adaptor.addChild(root_1, expression538.getTree());
 18722  
 
 18723  
 
 18724  0
                     match(input, Token.UP, null); 
 18725  0
                     adaptor.addChild(root_0, root_1);
 18726  0
                     _last = _save_last_1;
 18727  
                     }
 18728  
 
 18729  
 
 18730  
                     }
 18731  0
                     break;
 18732  
                 case 6 :
 18733  
                     // com\\googlecode\\sparkleg\\SparqlT.g:531:7: ^( SAMPLE ( DISTINCT )? expression )
 18734  
                     {
 18735  0
                     root_0 = (CommonTree)adaptor.nil();
 18736  
 
 18737  
 
 18738  0
                     _last = (CommonTree)input.LT(1);
 18739  
                     {
 18740  0
                     CommonTree _save_last_1 = _last;
 18741  0
                     CommonTree _first_1 = null;
 18742  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 18743  0
                     _last = (CommonTree)input.LT(1);
 18744  0
                     SAMPLE539=(CommonTree)match(input,SAMPLE,FOLLOW_SAMPLE_in_aggregate3966); 
 18745  0
                     SAMPLE539_tree = (CommonTree)adaptor.dupNode(SAMPLE539);
 18746  
 
 18747  
 
 18748  0
                     root_1 = (CommonTree)adaptor.becomeRoot(SAMPLE539_tree, root_1);
 18749  
 
 18750  
 
 18751  0
                     match(input, Token.DOWN, null); 
 18752  
                     // com\\googlecode\\sparkleg\\SparqlT.g:531:16: ( DISTINCT )?
 18753  0
                     int alt140=2;
 18754  0
                     switch ( input.LA(1) ) {
 18755  
                         case DISTINCT:
 18756  
                             {
 18757  0
                             alt140=1;
 18758  
                             }
 18759  
                             break;
 18760  
                     }
 18761  
 
 18762  0
                     switch (alt140) {
 18763  
                         case 1 :
 18764  
                             // com\\googlecode\\sparkleg\\SparqlT.g:531:16: DISTINCT
 18765  
                             {
 18766  0
                             _last = (CommonTree)input.LT(1);
 18767  0
                             DISTINCT540=(CommonTree)match(input,DISTINCT,FOLLOW_DISTINCT_in_aggregate3968); 
 18768  0
                             DISTINCT540_tree = (CommonTree)adaptor.dupNode(DISTINCT540);
 18769  
 
 18770  
 
 18771  0
                             adaptor.addChild(root_1, DISTINCT540_tree);
 18772  
 
 18773  
 
 18774  
                             }
 18775  
                             break;
 18776  
 
 18777  
                     }
 18778  
 
 18779  
 
 18780  0
                     _last = (CommonTree)input.LT(1);
 18781  0
                     pushFollow(FOLLOW_expression_in_aggregate3971);
 18782  0
                     expression541=expression();
 18783  
 
 18784  0
                     state._fsp--;
 18785  
 
 18786  0
                     adaptor.addChild(root_1, expression541.getTree());
 18787  
 
 18788  
 
 18789  0
                     match(input, Token.UP, null); 
 18790  0
                     adaptor.addChild(root_0, root_1);
 18791  0
                     _last = _save_last_1;
 18792  
                     }
 18793  
 
 18794  
 
 18795  
                     }
 18796  0
                     break;
 18797  
                 case 7 :
 18798  
                     // com\\googlecode\\sparkleg\\SparqlT.g:532:7: ^( GROUP_CONCAT ( DISTINCT )* expression ( string )? )
 18799  
                     {
 18800  0
                     root_0 = (CommonTree)adaptor.nil();
 18801  
 
 18802  
 
 18803  0
                     _last = (CommonTree)input.LT(1);
 18804  
                     {
 18805  0
                     CommonTree _save_last_1 = _last;
 18806  0
                     CommonTree _first_1 = null;
 18807  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 18808  0
                     _last = (CommonTree)input.LT(1);
 18809  0
                     GROUP_CONCAT542=(CommonTree)match(input,GROUP_CONCAT,FOLLOW_GROUP_CONCAT_in_aggregate3981); 
 18810  0
                     GROUP_CONCAT542_tree = (CommonTree)adaptor.dupNode(GROUP_CONCAT542);
 18811  
 
 18812  
 
 18813  0
                     root_1 = (CommonTree)adaptor.becomeRoot(GROUP_CONCAT542_tree, root_1);
 18814  
 
 18815  
 
 18816  0
                     match(input, Token.DOWN, null); 
 18817  
                     // com\\googlecode\\sparkleg\\SparqlT.g:532:22: ( DISTINCT )*
 18818  
                     loop141:
 18819  
                     do {
 18820  0
                         int alt141=2;
 18821  0
                         switch ( input.LA(1) ) {
 18822  
                         case DISTINCT:
 18823  
                             {
 18824  0
                             alt141=1;
 18825  
                             }
 18826  
                             break;
 18827  
 
 18828  
                         }
 18829  
 
 18830  0
                         switch (alt141) {
 18831  
                             case 1 :
 18832  
                                 // com\\googlecode\\sparkleg\\SparqlT.g:532:22: DISTINCT
 18833  
                                 {
 18834  0
                                 _last = (CommonTree)input.LT(1);
 18835  0
                                 DISTINCT543=(CommonTree)match(input,DISTINCT,FOLLOW_DISTINCT_in_aggregate3983); 
 18836  0
                                 DISTINCT543_tree = (CommonTree)adaptor.dupNode(DISTINCT543);
 18837  
 
 18838  
 
 18839  0
                                 adaptor.addChild(root_1, DISTINCT543_tree);
 18840  
 
 18841  
 
 18842  
                                 }
 18843  0
                                 break;
 18844  
 
 18845  
                             default :
 18846  0
                                 break loop141;
 18847  
                         }
 18848  0
                     } while (true);
 18849  
 
 18850  
 
 18851  0
                     _last = (CommonTree)input.LT(1);
 18852  0
                     pushFollow(FOLLOW_expression_in_aggregate3986);
 18853  0
                     expression544=expression();
 18854  
 
 18855  0
                     state._fsp--;
 18856  
 
 18857  0
                     adaptor.addChild(root_1, expression544.getTree());
 18858  
 
 18859  
 
 18860  
                     // com\\googlecode\\sparkleg\\SparqlT.g:532:43: ( string )?
 18861  0
                     int alt142=2;
 18862  0
                     switch ( input.LA(1) ) {
 18863  
                         case STRING_LITERAL1:
 18864  
                         case STRING_LITERAL2:
 18865  
                         case STRING_LITERAL_LONG1:
 18866  
                         case STRING_LITERAL_LONG2:
 18867  
                             {
 18868  0
                             alt142=1;
 18869  
                             }
 18870  
                             break;
 18871  
                     }
 18872  
 
 18873  0
                     switch (alt142) {
 18874  
                         case 1 :
 18875  
                             // com\\googlecode\\sparkleg\\SparqlT.g:532:43: string
 18876  
                             {
 18877  0
                             _last = (CommonTree)input.LT(1);
 18878  0
                             pushFollow(FOLLOW_string_in_aggregate3988);
 18879  0
                             string545=string();
 18880  
 
 18881  0
                             state._fsp--;
 18882  
 
 18883  0
                             adaptor.addChild(root_1, string545.getTree());
 18884  
 
 18885  
 
 18886  
                             }
 18887  
                             break;
 18888  
 
 18889  
                     }
 18890  
 
 18891  
 
 18892  0
                     match(input, Token.UP, null); 
 18893  0
                     adaptor.addChild(root_0, root_1);
 18894  0
                     _last = _save_last_1;
 18895  
                     }
 18896  
 
 18897  
 
 18898  
                     }
 18899  
                     break;
 18900  
 
 18901  
             }
 18902  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 18903  
 
 18904  
         }
 18905  0
         catch (RecognitionException re) {
 18906  0
             reportError(re);
 18907  0
             recover(input,re);
 18908  
         }
 18909  
 
 18910  0
         finally {
 18911  
                 // do for sure before leaving
 18912  0
         }
 18913  0
         return retval;
 18914  
     }
 18915  
     // $ANTLR end "aggregate"
 18916  
 
 18917  
 
 18918  0
     public static class iriRefOrFunction_return extends TreeRuleReturnScope {
 18919  
         CommonTree tree;
 18920  0
         public Object getTree() { return tree; }
 18921  
     };
 18922  
 
 18923  
 
 18924  
     // $ANTLR start "iriRefOrFunction"
 18925  
     // com\\googlecode\\sparkleg\\SparqlT.g:535:1: iriRefOrFunction : ( ^( FUNCTION f= iriRef ^( ARG_LIST (a= argList ) ) ) | ^( FUNCTION f= iriRef ) );
 18926  
     public final SparqlT.iriRefOrFunction_return iriRefOrFunction() throws RecognitionException {
 18927  0
         SparqlT.iriRefOrFunction_return retval = new SparqlT.iriRefOrFunction_return();
 18928  0
         retval.start = input.LT(1);
 18929  
 
 18930  
 
 18931  0
         CommonTree root_0 = null;
 18932  
 
 18933  0
         CommonTree _first_0 = null;
 18934  0
         CommonTree _last = null;
 18935  
 
 18936  0
         CommonTree FUNCTION546=null;
 18937  0
         CommonTree ARG_LIST547=null;
 18938  0
         CommonTree FUNCTION548=null;
 18939  0
         SparqlT.iriRef_return f =null;
 18940  
 
 18941  0
         SparqlT.argList_return a =null;
 18942  
 
 18943  
 
 18944  0
         CommonTree FUNCTION546_tree=null;
 18945  0
         CommonTree ARG_LIST547_tree=null;
 18946  0
         CommonTree FUNCTION548_tree=null;
 18947  
 
 18948  
         try {
 18949  
             // com\\googlecode\\sparkleg\\SparqlT.g:536:5: ( ^( FUNCTION f= iriRef ^( ARG_LIST (a= argList ) ) ) | ^( FUNCTION f= iriRef ) )
 18950  0
             int alt144=2;
 18951  0
             switch ( input.LA(1) ) {
 18952  
             case FUNCTION:
 18953  
                 {
 18954  0
                 switch ( input.LA(2) ) {
 18955  
                 case DOWN:
 18956  
                     {
 18957  0
                     switch ( input.LA(3) ) {
 18958  
                     case IRI_REF:
 18959  
                         {
 18960  0
                         switch ( input.LA(4) ) {
 18961  
                         case ARG_LIST:
 18962  
                             {
 18963  0
                             alt144=1;
 18964  
                             }
 18965  0
                             break;
 18966  
                         case UP:
 18967  
                             {
 18968  0
                             alt144=2;
 18969  
                             }
 18970  0
                             break;
 18971  
                         default:
 18972  0
                             NoViableAltException nvae =
 18973  
                                 new NoViableAltException("", 144, 3, input);
 18974  
 
 18975  0
                             throw nvae;
 18976  
 
 18977  
                         }
 18978  
 
 18979  
                         }
 18980  0
                         break;
 18981  
                     case PNAME_LN:
 18982  
                     case PNAME_NS:
 18983  
                         {
 18984  0
                         switch ( input.LA(4) ) {
 18985  
                         case ARG_LIST:
 18986  
                             {
 18987  0
                             alt144=1;
 18988  
                             }
 18989  0
                             break;
 18990  
                         case UP:
 18991  
                             {
 18992  0
                             alt144=2;
 18993  
                             }
 18994  0
                             break;
 18995  
                         default:
 18996  0
                             NoViableAltException nvae =
 18997  
                                 new NoViableAltException("", 144, 4, input);
 18998  
 
 18999  0
                             throw nvae;
 19000  
 
 19001  
                         }
 19002  
 
 19003  
                         }
 19004  0
                         break;
 19005  
                     default:
 19006  0
                         NoViableAltException nvae =
 19007  
                             new NoViableAltException("", 144, 2, input);
 19008  
 
 19009  0
                         throw nvae;
 19010  
 
 19011  
                     }
 19012  
 
 19013  
                     }
 19014  0
                     break;
 19015  
                 default:
 19016  0
                     NoViableAltException nvae =
 19017  
                         new NoViableAltException("", 144, 1, input);
 19018  
 
 19019  0
                     throw nvae;
 19020  
 
 19021  
                 }
 19022  
 
 19023  
                 }
 19024  0
                 break;
 19025  
             default:
 19026  0
                 NoViableAltException nvae =
 19027  
                     new NoViableAltException("", 144, 0, input);
 19028  
 
 19029  0
                 throw nvae;
 19030  
 
 19031  
             }
 19032  
 
 19033  0
             switch (alt144) {
 19034  
                 case 1 :
 19035  
                     // com\\googlecode\\sparkleg\\SparqlT.g:536:7: ^( FUNCTION f= iriRef ^( ARG_LIST (a= argList ) ) )
 19036  
                     {
 19037  0
                     root_0 = (CommonTree)adaptor.nil();
 19038  
 
 19039  
 
 19040  0
                     _last = (CommonTree)input.LT(1);
 19041  
                     {
 19042  0
                     CommonTree _save_last_1 = _last;
 19043  0
                     CommonTree _first_1 = null;
 19044  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 19045  0
                     _last = (CommonTree)input.LT(1);
 19046  0
                     FUNCTION546=(CommonTree)match(input,FUNCTION,FOLLOW_FUNCTION_in_iriRefOrFunction4012); 
 19047  0
                     FUNCTION546_tree = (CommonTree)adaptor.dupNode(FUNCTION546);
 19048  
 
 19049  
 
 19050  0
                     root_1 = (CommonTree)adaptor.becomeRoot(FUNCTION546_tree, root_1);
 19051  
 
 19052  
 
 19053  0
                     match(input, Token.DOWN, null); 
 19054  0
                     _last = (CommonTree)input.LT(1);
 19055  0
                     pushFollow(FOLLOW_iriRef_in_iriRefOrFunction4016);
 19056  0
                     f=iriRef();
 19057  
 
 19058  0
                     state._fsp--;
 19059  
 
 19060  0
                     adaptor.addChild(root_1, f.getTree());
 19061  
 
 19062  
 
 19063  0
                     _last = (CommonTree)input.LT(1);
 19064  
                     {
 19065  0
                     CommonTree _save_last_2 = _last;
 19066  0
                     CommonTree _first_2 = null;
 19067  0
                     CommonTree root_2 = (CommonTree)adaptor.nil();
 19068  0
                     _last = (CommonTree)input.LT(1);
 19069  0
                     ARG_LIST547=(CommonTree)match(input,ARG_LIST,FOLLOW_ARG_LIST_in_iriRefOrFunction4019); 
 19070  0
                     ARG_LIST547_tree = (CommonTree)adaptor.dupNode(ARG_LIST547);
 19071  
 
 19072  
 
 19073  0
                     root_2 = (CommonTree)adaptor.becomeRoot(ARG_LIST547_tree, root_2);
 19074  
 
 19075  
 
 19076  0
                     if ( input.LA(1)==Token.DOWN ) {
 19077  0
                         match(input, Token.DOWN, null); 
 19078  
                         // com\\googlecode\\sparkleg\\SparqlT.g:536:38: (a= argList )
 19079  
                         // com\\googlecode\\sparkleg\\SparqlT.g:536:39: a= argList
 19080  
                         {
 19081  0
                         _last = (CommonTree)input.LT(1);
 19082  0
                         pushFollow(FOLLOW_argList_in_iriRefOrFunction4024);
 19083  0
                         a=argList();
 19084  
 
 19085  0
                         state._fsp--;
 19086  
 
 19087  0
                         adaptor.addChild(root_2, a.getTree());
 19088  
 
 19089  
 
 19090  
                         }
 19091  
 
 19092  
 
 19093  0
                         match(input, Token.UP, null); 
 19094  
                     }
 19095  0
                     adaptor.addChild(root_1, root_2);
 19096  0
                     _last = _save_last_2;
 19097  
                     }
 19098  
 
 19099  
 
 19100  0
                     match(input, Token.UP, null); 
 19101  0
                     adaptor.addChild(root_0, root_1);
 19102  0
                     _last = _save_last_1;
 19103  
                     }
 19104  
 
 19105  
 
 19106  
                     }
 19107  0
                     break;
 19108  
                 case 2 :
 19109  
                     // com\\googlecode\\sparkleg\\SparqlT.g:537:7: ^( FUNCTION f= iriRef )
 19110  
                     {
 19111  0
                     root_0 = (CommonTree)adaptor.nil();
 19112  
 
 19113  
 
 19114  0
                     _last = (CommonTree)input.LT(1);
 19115  
                     {
 19116  0
                     CommonTree _save_last_1 = _last;
 19117  0
                     CommonTree _first_1 = null;
 19118  0
                     CommonTree root_1 = (CommonTree)adaptor.nil();
 19119  0
                     _last = (CommonTree)input.LT(1);
 19120  0
                     FUNCTION548=(CommonTree)match(input,FUNCTION,FOLLOW_FUNCTION_in_iriRefOrFunction4036); 
 19121  0
                     FUNCTION548_tree = (CommonTree)adaptor.dupNode(FUNCTION548);
 19122  
 
 19123  
 
 19124  0
                     root_1 = (CommonTree)adaptor.becomeRoot(FUNCTION548_tree, root_1);
 19125  
 
 19126  
 
 19127  0
                     match(input, Token.DOWN, null); 
 19128  0
                     _last = (CommonTree)input.LT(1);
 19129  0
                     pushFollow(FOLLOW_iriRef_in_iriRefOrFunction4040);
 19130  0
                     f=iriRef();
 19131  
 
 19132  0
                     state._fsp--;
 19133  
 
 19134  0
                     adaptor.addChild(root_1, f.getTree());
 19135  
 
 19136  
 
 19137  0
                     match(input, Token.UP, null); 
 19138  0
                     adaptor.addChild(root_0, root_1);
 19139  0
                     _last = _save_last_1;
 19140  
                     }
 19141  
 
 19142  
 
 19143  
                     }
 19144  
                     break;
 19145  
 
 19146  
             }
 19147  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 19148  
 
 19149  
         }
 19150  0
         catch (RecognitionException re) {
 19151  0
             reportError(re);
 19152  0
             recover(input,re);
 19153  
         }
 19154  
 
 19155  0
         finally {
 19156  
                 // do for sure before leaving
 19157  0
         }
 19158  0
         return retval;
 19159  
     }
 19160  
     // $ANTLR end "iriRefOrFunction"
 19161  
 
 19162  
 
 19163  0
     public static class rdfLiteral_return extends TreeRuleReturnScope {
 19164  
         CommonTree tree;
 19165  0
         public Object getTree() { return tree; }
 19166  
     };
 19167  
 
 19168  
 
 19169  
     // $ANTLR start "rdfLiteral"
 19170  
     // com\\googlecode\\sparkleg\\SparqlT.g:540:1: rdfLiteral : string ( LANGTAG | ( REFERENCE iriRef ) )? ;
 19171  
     public final SparqlT.rdfLiteral_return rdfLiteral() throws RecognitionException {
 19172  0
         SparqlT.rdfLiteral_return retval = new SparqlT.rdfLiteral_return();
 19173  0
         retval.start = input.LT(1);
 19174  
 
 19175  
 
 19176  0
         CommonTree root_0 = null;
 19177  
 
 19178  0
         CommonTree _first_0 = null;
 19179  0
         CommonTree _last = null;
 19180  
 
 19181  0
         CommonTree LANGTAG550=null;
 19182  0
         CommonTree REFERENCE551=null;
 19183  0
         SparqlT.string_return string549 =null;
 19184  
 
 19185  0
         SparqlT.iriRef_return iriRef552 =null;
 19186  
 
 19187  
 
 19188  0
         CommonTree LANGTAG550_tree=null;
 19189  0
         CommonTree REFERENCE551_tree=null;
 19190  
 
 19191  
         try {
 19192  
             // com\\googlecode\\sparkleg\\SparqlT.g:541:5: ( string ( LANGTAG | ( REFERENCE iriRef ) )? )
 19193  
             // com\\googlecode\\sparkleg\\SparqlT.g:541:7: string ( LANGTAG | ( REFERENCE iriRef ) )?
 19194  
             {
 19195  0
             root_0 = (CommonTree)adaptor.nil();
 19196  
 
 19197  
 
 19198  0
             _last = (CommonTree)input.LT(1);
 19199  0
             pushFollow(FOLLOW_string_in_rdfLiteral4058);
 19200  0
             string549=string();
 19201  
 
 19202  0
             state._fsp--;
 19203  
 
 19204  0
             adaptor.addChild(root_0, string549.getTree());
 19205  
 
 19206  
 
 19207  
             // com\\googlecode\\sparkleg\\SparqlT.g:541:14: ( LANGTAG | ( REFERENCE iriRef ) )?
 19208  0
             int alt145=3;
 19209  0
             switch ( input.LA(1) ) {
 19210  
                 case LANGTAG:
 19211  
                     {
 19212  0
                     alt145=1;
 19213  
                     }
 19214  0
                     break;
 19215  
                 case REFERENCE:
 19216  
                     {
 19217  0
                     alt145=2;
 19218  
                     }
 19219  
                     break;
 19220  
             }
 19221  
 
 19222  0
             switch (alt145) {
 19223  
                 case 1 :
 19224  
                     // com\\googlecode\\sparkleg\\SparqlT.g:541:15: LANGTAG
 19225  
                     {
 19226  0
                     _last = (CommonTree)input.LT(1);
 19227  0
                     LANGTAG550=(CommonTree)match(input,LANGTAG,FOLLOW_LANGTAG_in_rdfLiteral4061); 
 19228  0
                     LANGTAG550_tree = (CommonTree)adaptor.dupNode(LANGTAG550);
 19229  
 
 19230  
 
 19231  0
                     adaptor.addChild(root_0, LANGTAG550_tree);
 19232  
 
 19233  
 
 19234  
                     }
 19235  0
                     break;
 19236  
                 case 2 :
 19237  
                     // com\\googlecode\\sparkleg\\SparqlT.g:541:25: ( REFERENCE iriRef )
 19238  
                     {
 19239  
                     // com\\googlecode\\sparkleg\\SparqlT.g:541:25: ( REFERENCE iriRef )
 19240  
                     // com\\googlecode\\sparkleg\\SparqlT.g:541:26: REFERENCE iriRef
 19241  
                     {
 19242  0
                     _last = (CommonTree)input.LT(1);
 19243  0
                     REFERENCE551=(CommonTree)match(input,REFERENCE,FOLLOW_REFERENCE_in_rdfLiteral4066); 
 19244  0
                     REFERENCE551_tree = (CommonTree)adaptor.dupNode(REFERENCE551);
 19245  
 
 19246  
 
 19247  0
                     adaptor.addChild(root_0, REFERENCE551_tree);
 19248  
 
 19249  
 
 19250  0
                     _last = (CommonTree)input.LT(1);
 19251  0
                     pushFollow(FOLLOW_iriRef_in_rdfLiteral4068);
 19252  0
                     iriRef552=iriRef();
 19253  
 
 19254  0
                     state._fsp--;
 19255  
 
 19256  0
                     adaptor.addChild(root_0, iriRef552.getTree());
 19257  
 
 19258  
 
 19259  
                     }
 19260  
 
 19261  
 
 19262  
                     }
 19263  
                     break;
 19264  
 
 19265  
             }
 19266  
 
 19267  
 
 19268  
             }
 19269  
 
 19270  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 19271  
 
 19272  
         }
 19273  0
         catch (RecognitionException re) {
 19274  0
             reportError(re);
 19275  0
             recover(input,re);
 19276  
         }
 19277  
 
 19278  0
         finally {
 19279  
                 // do for sure before leaving
 19280  0
         }
 19281  0
         return retval;
 19282  
     }
 19283  
     // $ANTLR end "rdfLiteral"
 19284  
 
 19285  
 
 19286  0
     public static class numericLiteral_return extends TreeRuleReturnScope {
 19287  
         CommonTree tree;
 19288  0
         public Object getTree() { return tree; }
 19289  
     };
 19290  
 
 19291  
 
 19292  
     // $ANTLR start "numericLiteral"
 19293  
     // com\\googlecode\\sparkleg\\SparqlT.g:544:1: numericLiteral : ( numericLiteralUnsigned | numericLiteralPositive | numericLiteralNegative );
 19294  
     public final SparqlT.numericLiteral_return numericLiteral() throws RecognitionException {
 19295  0
         SparqlT.numericLiteral_return retval = new SparqlT.numericLiteral_return();
 19296  0
         retval.start = input.LT(1);
 19297  
 
 19298  
 
 19299  0
         CommonTree root_0 = null;
 19300  
 
 19301  0
         CommonTree _first_0 = null;
 19302  0
         CommonTree _last = null;
 19303  
 
 19304  0
         SparqlT.numericLiteralUnsigned_return numericLiteralUnsigned553 =null;
 19305  
 
 19306  0
         SparqlT.numericLiteralPositive_return numericLiteralPositive554 =null;
 19307  
 
 19308  0
         SparqlT.numericLiteralNegative_return numericLiteralNegative555 =null;
 19309  
 
 19310  
 
 19311  
 
 19312  
         try {
 19313  
             // com\\googlecode\\sparkleg\\SparqlT.g:545:5: ( numericLiteralUnsigned | numericLiteralPositive | numericLiteralNegative )
 19314  0
             int alt146=3;
 19315  0
             switch ( input.LA(1) ) {
 19316  
             case DECIMAL:
 19317  
             case DOUBLE:
 19318  
             case INTEGER:
 19319  
                 {
 19320  0
                 alt146=1;
 19321  
                 }
 19322  0
                 break;
 19323  
             case DECIMAL_POSITIVE:
 19324  
             case DOUBLE_POSITIVE:
 19325  
             case INTEGER_POSITIVE:
 19326  
                 {
 19327  0
                 alt146=2;
 19328  
                 }
 19329  0
                 break;
 19330  
             case DECIMAL_NEGATIVE:
 19331  
             case DOUBLE_NEGATIVE:
 19332  
             case INTEGER_NEGATIVE:
 19333  
                 {
 19334  0
                 alt146=3;
 19335  
                 }
 19336  0
                 break;
 19337  
             default:
 19338  0
                 NoViableAltException nvae =
 19339  
                     new NoViableAltException("", 146, 0, input);
 19340  
 
 19341  0
                 throw nvae;
 19342  
 
 19343  
             }
 19344  
 
 19345  0
             switch (alt146) {
 19346  
                 case 1 :
 19347  
                     // com\\googlecode\\sparkleg\\SparqlT.g:545:7: numericLiteralUnsigned
 19348  
                     {
 19349  0
                     root_0 = (CommonTree)adaptor.nil();
 19350  
 
 19351  
 
 19352  0
                     _last = (CommonTree)input.LT(1);
 19353  0
                     pushFollow(FOLLOW_numericLiteralUnsigned_in_numericLiteral4088);
 19354  0
                     numericLiteralUnsigned553=numericLiteralUnsigned();
 19355  
 
 19356  0
                     state._fsp--;
 19357  
 
 19358  0
                     adaptor.addChild(root_0, numericLiteralUnsigned553.getTree());
 19359  
 
 19360  
 
 19361  
                     }
 19362  0
                     break;
 19363  
                 case 2 :
 19364  
                     // com\\googlecode\\sparkleg\\SparqlT.g:546:7: numericLiteralPositive
 19365  
                     {
 19366  0
                     root_0 = (CommonTree)adaptor.nil();
 19367  
 
 19368  
 
 19369  0
                     _last = (CommonTree)input.LT(1);
 19370  0
                     pushFollow(FOLLOW_numericLiteralPositive_in_numericLiteral4096);
 19371  0
                     numericLiteralPositive554=numericLiteralPositive();
 19372  
 
 19373  0
                     state._fsp--;
 19374  
 
 19375  0
                     adaptor.addChild(root_0, numericLiteralPositive554.getTree());
 19376  
 
 19377  
 
 19378  
                     }
 19379  0
                     break;
 19380  
                 case 3 :
 19381  
                     // com\\googlecode\\sparkleg\\SparqlT.g:547:7: numericLiteralNegative
 19382  
                     {
 19383  0
                     root_0 = (CommonTree)adaptor.nil();
 19384  
 
 19385  
 
 19386  0
                     _last = (CommonTree)input.LT(1);
 19387  0
                     pushFollow(FOLLOW_numericLiteralNegative_in_numericLiteral4104);
 19388  0
                     numericLiteralNegative555=numericLiteralNegative();
 19389  
 
 19390  0
                     state._fsp--;
 19391  
 
 19392  0
                     adaptor.addChild(root_0, numericLiteralNegative555.getTree());
 19393  
 
 19394  
 
 19395  
                     }
 19396  
                     break;
 19397  
 
 19398  
             }
 19399  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 19400  
 
 19401  
         }
 19402  0
         catch (RecognitionException re) {
 19403  0
             reportError(re);
 19404  0
             recover(input,re);
 19405  
         }
 19406  
 
 19407  0
         finally {
 19408  
                 // do for sure before leaving
 19409  0
         }
 19410  0
         return retval;
 19411  
     }
 19412  
     // $ANTLR end "numericLiteral"
 19413  
 
 19414  
 
 19415  0
     public static class numericLiteralUnsigned_return extends TreeRuleReturnScope {
 19416  
         CommonTree tree;
 19417  0
         public Object getTree() { return tree; }
 19418  
     };
 19419  
 
 19420  
 
 19421  
     // $ANTLR start "numericLiteralUnsigned"
 19422  
     // com\\googlecode\\sparkleg\\SparqlT.g:550:1: numericLiteralUnsigned : ( INTEGER | DECIMAL | DOUBLE );
 19423  
     public final SparqlT.numericLiteralUnsigned_return numericLiteralUnsigned() throws RecognitionException {
 19424  0
         SparqlT.numericLiteralUnsigned_return retval = new SparqlT.numericLiteralUnsigned_return();
 19425  0
         retval.start = input.LT(1);
 19426  
 
 19427  
 
 19428  0
         CommonTree root_0 = null;
 19429  
 
 19430  0
         CommonTree _first_0 = null;
 19431  0
         CommonTree _last = null;
 19432  
 
 19433  0
         CommonTree set556=null;
 19434  
 
 19435  0
         CommonTree set556_tree=null;
 19436  
 
 19437  
         try {
 19438  
             // com\\googlecode\\sparkleg\\SparqlT.g:551:5: ( INTEGER | DECIMAL | DOUBLE )
 19439  
             // com\\googlecode\\sparkleg\\SparqlT.g:
 19440  
             {
 19441  0
             root_0 = (CommonTree)adaptor.nil();
 19442  
 
 19443  
 
 19444  0
             _last = (CommonTree)input.LT(1);
 19445  0
             set556=(CommonTree)input.LT(1);
 19446  
 
 19447  0
             if ( input.LA(1)==DECIMAL||input.LA(1)==DOUBLE||input.LA(1)==INTEGER ) {
 19448  0
                 input.consume();
 19449  0
                 set556_tree = (CommonTree)adaptor.dupNode(set556);
 19450  
 
 19451  
 
 19452  0
                 adaptor.addChild(root_0, set556_tree);
 19453  
 
 19454  0
                 state.errorRecovery=false;
 19455  
             }
 19456  
             else {
 19457  0
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 19458  0
                 throw mse;
 19459  
             }
 19460  
 
 19461  
              
 19462  
 
 19463  
             }
 19464  
 
 19465  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 19466  
 
 19467  
         }
 19468  0
         catch (RecognitionException re) {
 19469  0
             reportError(re);
 19470  0
             recover(input,re);
 19471  
         }
 19472  
 
 19473  0
         finally {
 19474  
                 // do for sure before leaving
 19475  0
         }
 19476  0
         return retval;
 19477  
     }
 19478  
     // $ANTLR end "numericLiteralUnsigned"
 19479  
 
 19480  
 
 19481  0
     public static class numericLiteralPositive_return extends TreeRuleReturnScope {
 19482  
         CommonTree tree;
 19483  0
         public Object getTree() { return tree; }
 19484  
     };
 19485  
 
 19486  
 
 19487  
     // $ANTLR start "numericLiteralPositive"
 19488  
     // com\\googlecode\\sparkleg\\SparqlT.g:556:1: numericLiteralPositive : ( INTEGER_POSITIVE | DECIMAL_POSITIVE | DOUBLE_POSITIVE );
 19489  
     public final SparqlT.numericLiteralPositive_return numericLiteralPositive() throws RecognitionException {
 19490  0
         SparqlT.numericLiteralPositive_return retval = new SparqlT.numericLiteralPositive_return();
 19491  0
         retval.start = input.LT(1);
 19492  
 
 19493  
 
 19494  0
         CommonTree root_0 = null;
 19495  
 
 19496  0
         CommonTree _first_0 = null;
 19497  0
         CommonTree _last = null;
 19498  
 
 19499  0
         CommonTree set557=null;
 19500  
 
 19501  0
         CommonTree set557_tree=null;
 19502  
 
 19503  
         try {
 19504  
             // com\\googlecode\\sparkleg\\SparqlT.g:557:5: ( INTEGER_POSITIVE | DECIMAL_POSITIVE | DOUBLE_POSITIVE )
 19505  
             // com\\googlecode\\sparkleg\\SparqlT.g:
 19506  
             {
 19507  0
             root_0 = (CommonTree)adaptor.nil();
 19508  
 
 19509  
 
 19510  0
             _last = (CommonTree)input.LT(1);
 19511  0
             set557=(CommonTree)input.LT(1);
 19512  
 
 19513  0
             if ( input.LA(1)==DECIMAL_POSITIVE||input.LA(1)==DOUBLE_POSITIVE||input.LA(1)==INTEGER_POSITIVE ) {
 19514  0
                 input.consume();
 19515  0
                 set557_tree = (CommonTree)adaptor.dupNode(set557);
 19516  
 
 19517  
 
 19518  0
                 adaptor.addChild(root_0, set557_tree);
 19519  
 
 19520  0
                 state.errorRecovery=false;
 19521  
             }
 19522  
             else {
 19523  0
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 19524  0
                 throw mse;
 19525  
             }
 19526  
 
 19527  
              
 19528  
 
 19529  
             }
 19530  
 
 19531  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 19532  
 
 19533  
         }
 19534  0
         catch (RecognitionException re) {
 19535  0
             reportError(re);
 19536  0
             recover(input,re);
 19537  
         }
 19538  
 
 19539  0
         finally {
 19540  
                 // do for sure before leaving
 19541  0
         }
 19542  0
         return retval;
 19543  
     }
 19544  
     // $ANTLR end "numericLiteralPositive"
 19545  
 
 19546  
 
 19547  0
     public static class numericLiteralNegative_return extends TreeRuleReturnScope {
 19548  
         CommonTree tree;
 19549  0
         public Object getTree() { return tree; }
 19550  
     };
 19551  
 
 19552  
 
 19553  
     // $ANTLR start "numericLiteralNegative"
 19554  
     // com\\googlecode\\sparkleg\\SparqlT.g:562:1: numericLiteralNegative : ( INTEGER_NEGATIVE | DECIMAL_NEGATIVE | DOUBLE_NEGATIVE );
 19555  
     public final SparqlT.numericLiteralNegative_return numericLiteralNegative() throws RecognitionException {
 19556  0
         SparqlT.numericLiteralNegative_return retval = new SparqlT.numericLiteralNegative_return();
 19557  0
         retval.start = input.LT(1);
 19558  
 
 19559  
 
 19560  0
         CommonTree root_0 = null;
 19561  
 
 19562  0
         CommonTree _first_0 = null;
 19563  0
         CommonTree _last = null;
 19564  
 
 19565  0
         CommonTree set558=null;
 19566  
 
 19567  0
         CommonTree set558_tree=null;
 19568  
 
 19569  
         try {
 19570  
             // com\\googlecode\\sparkleg\\SparqlT.g:563:5: ( INTEGER_NEGATIVE | DECIMAL_NEGATIVE | DOUBLE_NEGATIVE )
 19571  
             // com\\googlecode\\sparkleg\\SparqlT.g:
 19572  
             {
 19573  0
             root_0 = (CommonTree)adaptor.nil();
 19574  
 
 19575  
 
 19576  0
             _last = (CommonTree)input.LT(1);
 19577  0
             set558=(CommonTree)input.LT(1);
 19578  
 
 19579  0
             if ( input.LA(1)==DECIMAL_NEGATIVE||input.LA(1)==DOUBLE_NEGATIVE||input.LA(1)==INTEGER_NEGATIVE ) {
 19580  0
                 input.consume();
 19581  0
                 set558_tree = (CommonTree)adaptor.dupNode(set558);
 19582  
 
 19583  
 
 19584  0
                 adaptor.addChild(root_0, set558_tree);
 19585  
 
 19586  0
                 state.errorRecovery=false;
 19587  
             }
 19588  
             else {
 19589  0
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 19590  0
                 throw mse;
 19591  
             }
 19592  
 
 19593  
              
 19594  
 
 19595  
             }
 19596  
 
 19597  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 19598  
 
 19599  
         }
 19600  0
         catch (RecognitionException re) {
 19601  0
             reportError(re);
 19602  0
             recover(input,re);
 19603  
         }
 19604  
 
 19605  0
         finally {
 19606  
                 // do for sure before leaving
 19607  0
         }
 19608  0
         return retval;
 19609  
     }
 19610  
     // $ANTLR end "numericLiteralNegative"
 19611  
 
 19612  
 
 19613  0
     public static class booleanLiteral_return extends TreeRuleReturnScope {
 19614  
         CommonTree tree;
 19615  0
         public Object getTree() { return tree; }
 19616  
     };
 19617  
 
 19618  
 
 19619  
     // $ANTLR start "booleanLiteral"
 19620  
     // com\\googlecode\\sparkleg\\SparqlT.g:568:1: booleanLiteral : ( TRUE | FALSE );
 19621  
     public final SparqlT.booleanLiteral_return booleanLiteral() throws RecognitionException {
 19622  0
         SparqlT.booleanLiteral_return retval = new SparqlT.booleanLiteral_return();
 19623  0
         retval.start = input.LT(1);
 19624  
 
 19625  
 
 19626  0
         CommonTree root_0 = null;
 19627  
 
 19628  0
         CommonTree _first_0 = null;
 19629  0
         CommonTree _last = null;
 19630  
 
 19631  0
         CommonTree set559=null;
 19632  
 
 19633  0
         CommonTree set559_tree=null;
 19634  
 
 19635  
         try {
 19636  
             // com\\googlecode\\sparkleg\\SparqlT.g:569:5: ( TRUE | FALSE )
 19637  
             // com\\googlecode\\sparkleg\\SparqlT.g:
 19638  
             {
 19639  0
             root_0 = (CommonTree)adaptor.nil();
 19640  
 
 19641  
 
 19642  0
             _last = (CommonTree)input.LT(1);
 19643  0
             set559=(CommonTree)input.LT(1);
 19644  
 
 19645  0
             if ( input.LA(1)==FALSE||input.LA(1)==TRUE ) {
 19646  0
                 input.consume();
 19647  0
                 set559_tree = (CommonTree)adaptor.dupNode(set559);
 19648  
 
 19649  
 
 19650  0
                 adaptor.addChild(root_0, set559_tree);
 19651  
 
 19652  0
                 state.errorRecovery=false;
 19653  
             }
 19654  
             else {
 19655  0
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 19656  0
                 throw mse;
 19657  
             }
 19658  
 
 19659  
              
 19660  
 
 19661  
             }
 19662  
 
 19663  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 19664  
 
 19665  
         }
 19666  0
         catch (RecognitionException re) {
 19667  0
             reportError(re);
 19668  0
             recover(input,re);
 19669  
         }
 19670  
 
 19671  0
         finally {
 19672  
                 // do for sure before leaving
 19673  0
         }
 19674  0
         return retval;
 19675  
     }
 19676  
     // $ANTLR end "booleanLiteral"
 19677  
 
 19678  
 
 19679  0
     public static class string_return extends TreeRuleReturnScope {
 19680  
         CommonTree tree;
 19681  0
         public Object getTree() { return tree; }
 19682  
     };
 19683  
 
 19684  
 
 19685  
     // $ANTLR start "string"
 19686  
     // com\\googlecode\\sparkleg\\SparqlT.g:573:1: string : ( STRING_LITERAL1 | STRING_LITERAL2 | STRING_LITERAL_LONG1 | STRING_LITERAL_LONG2 );
 19687  
     public final SparqlT.string_return string() throws RecognitionException {
 19688  0
         SparqlT.string_return retval = new SparqlT.string_return();
 19689  0
         retval.start = input.LT(1);
 19690  
 
 19691  
 
 19692  0
         CommonTree root_0 = null;
 19693  
 
 19694  0
         CommonTree _first_0 = null;
 19695  0
         CommonTree _last = null;
 19696  
 
 19697  0
         CommonTree set560=null;
 19698  
 
 19699  0
         CommonTree set560_tree=null;
 19700  
 
 19701  
         try {
 19702  
             // com\\googlecode\\sparkleg\\SparqlT.g:574:5: ( STRING_LITERAL1 | STRING_LITERAL2 | STRING_LITERAL_LONG1 | STRING_LITERAL_LONG2 )
 19703  
             // com\\googlecode\\sparkleg\\SparqlT.g:
 19704  
             {
 19705  0
             root_0 = (CommonTree)adaptor.nil();
 19706  
 
 19707  
 
 19708  0
             _last = (CommonTree)input.LT(1);
 19709  0
             set560=(CommonTree)input.LT(1);
 19710  
 
 19711  0
             if ( (input.LA(1) >= STRING_LITERAL1 && input.LA(1) <= STRING_LITERAL_LONG2) ) {
 19712  0
                 input.consume();
 19713  0
                 set560_tree = (CommonTree)adaptor.dupNode(set560);
 19714  
 
 19715  
 
 19716  0
                 adaptor.addChild(root_0, set560_tree);
 19717  
 
 19718  0
                 state.errorRecovery=false;
 19719  
             }
 19720  
             else {
 19721  0
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 19722  0
                 throw mse;
 19723  
             }
 19724  
 
 19725  
              
 19726  
 
 19727  
             }
 19728  
 
 19729  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 19730  
 
 19731  
         }
 19732  0
         catch (RecognitionException re) {
 19733  0
             reportError(re);
 19734  0
             recover(input,re);
 19735  
         }
 19736  
 
 19737  0
         finally {
 19738  
                 // do for sure before leaving
 19739  0
         }
 19740  0
         return retval;
 19741  
     }
 19742  
     // $ANTLR end "string"
 19743  
 
 19744  
 
 19745  0
     public static class iriRef_return extends TreeRuleReturnScope {
 19746  
         CommonTree tree;
 19747  0
         public Object getTree() { return tree; }
 19748  
     };
 19749  
 
 19750  
 
 19751  
     // $ANTLR start "iriRef"
 19752  
     // com\\googlecode\\sparkleg\\SparqlT.g:580:1: iriRef : ( IRI_REF | prefixedName );
 19753  
     public final SparqlT.iriRef_return iriRef() throws RecognitionException {
 19754  0
         SparqlT.iriRef_return retval = new SparqlT.iriRef_return();
 19755  0
         retval.start = input.LT(1);
 19756  
 
 19757  
 
 19758  0
         CommonTree root_0 = null;
 19759  
 
 19760  0
         CommonTree _first_0 = null;
 19761  0
         CommonTree _last = null;
 19762  
 
 19763  0
         CommonTree IRI_REF561=null;
 19764  0
         SparqlT.prefixedName_return prefixedName562 =null;
 19765  
 
 19766  
 
 19767  0
         CommonTree IRI_REF561_tree=null;
 19768  
 
 19769  
         try {
 19770  
             // com\\googlecode\\sparkleg\\SparqlT.g:581:5: ( IRI_REF | prefixedName )
 19771  0
             int alt147=2;
 19772  0
             switch ( input.LA(1) ) {
 19773  
             case IRI_REF:
 19774  
                 {
 19775  0
                 alt147=1;
 19776  
                 }
 19777  0
                 break;
 19778  
             case PNAME_LN:
 19779  
             case PNAME_NS:
 19780  
                 {
 19781  0
                 alt147=2;
 19782  
                 }
 19783  0
                 break;
 19784  
             default:
 19785  0
                 NoViableAltException nvae =
 19786  
                     new NoViableAltException("", 147, 0, input);
 19787  
 
 19788  0
                 throw nvae;
 19789  
 
 19790  
             }
 19791  
 
 19792  0
             switch (alt147) {
 19793  
                 case 1 :
 19794  
                     // com\\googlecode\\sparkleg\\SparqlT.g:581:7: IRI_REF
 19795  
                     {
 19796  0
                     root_0 = (CommonTree)adaptor.nil();
 19797  
 
 19798  
 
 19799  0
                     _last = (CommonTree)input.LT(1);
 19800  0
                     IRI_REF561=(CommonTree)match(input,IRI_REF,FOLLOW_IRI_REF_in_iriRef4287); 
 19801  0
                     IRI_REF561_tree = (CommonTree)adaptor.dupNode(IRI_REF561);
 19802  
 
 19803  
 
 19804  0
                     adaptor.addChild(root_0, IRI_REF561_tree);
 19805  
 
 19806  
 
 19807  
                     }
 19808  0
                     break;
 19809  
                 case 2 :
 19810  
                     // com\\googlecode\\sparkleg\\SparqlT.g:582:7: prefixedName
 19811  
                     {
 19812  0
                     root_0 = (CommonTree)adaptor.nil();
 19813  
 
 19814  
 
 19815  0
                     _last = (CommonTree)input.LT(1);
 19816  0
                     pushFollow(FOLLOW_prefixedName_in_iriRef4295);
 19817  0
                     prefixedName562=prefixedName();
 19818  
 
 19819  0
                     state._fsp--;
 19820  
 
 19821  0
                     adaptor.addChild(root_0, prefixedName562.getTree());
 19822  
 
 19823  
 
 19824  
                     }
 19825  
                     break;
 19826  
 
 19827  
             }
 19828  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 19829  
 
 19830  
         }
 19831  0
         catch (RecognitionException re) {
 19832  0
             reportError(re);
 19833  0
             recover(input,re);
 19834  
         }
 19835  
 
 19836  0
         finally {
 19837  
                 // do for sure before leaving
 19838  0
         }
 19839  0
         return retval;
 19840  
     }
 19841  
     // $ANTLR end "iriRef"
 19842  
 
 19843  
 
 19844  0
     public static class prefixedName_return extends TreeRuleReturnScope {
 19845  
         CommonTree tree;
 19846  0
         public Object getTree() { return tree; }
 19847  
     };
 19848  
 
 19849  
 
 19850  
     // $ANTLR start "prefixedName"
 19851  
     // com\\googlecode\\sparkleg\\SparqlT.g:585:1: prefixedName : ( PNAME_LN | PNAME_NS );
 19852  
     public final SparqlT.prefixedName_return prefixedName() throws RecognitionException {
 19853  0
         SparqlT.prefixedName_return retval = new SparqlT.prefixedName_return();
 19854  0
         retval.start = input.LT(1);
 19855  
 
 19856  
 
 19857  0
         CommonTree root_0 = null;
 19858  
 
 19859  0
         CommonTree _first_0 = null;
 19860  0
         CommonTree _last = null;
 19861  
 
 19862  0
         CommonTree set563=null;
 19863  
 
 19864  0
         CommonTree set563_tree=null;
 19865  
 
 19866  
         try {
 19867  
             // com\\googlecode\\sparkleg\\SparqlT.g:586:5: ( PNAME_LN | PNAME_NS )
 19868  
             // com\\googlecode\\sparkleg\\SparqlT.g:
 19869  
             {
 19870  0
             root_0 = (CommonTree)adaptor.nil();
 19871  
 
 19872  
 
 19873  0
             _last = (CommonTree)input.LT(1);
 19874  0
             set563=(CommonTree)input.LT(1);
 19875  
 
 19876  0
             if ( (input.LA(1) >= PNAME_LN && input.LA(1) <= PNAME_NS) ) {
 19877  0
                 input.consume();
 19878  0
                 set563_tree = (CommonTree)adaptor.dupNode(set563);
 19879  
 
 19880  
 
 19881  0
                 adaptor.addChild(root_0, set563_tree);
 19882  
 
 19883  0
                 state.errorRecovery=false;
 19884  
             }
 19885  
             else {
 19886  0
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 19887  0
                 throw mse;
 19888  
             }
 19889  
 
 19890  
              
 19891  
 
 19892  
             }
 19893  
 
 19894  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 19895  
 
 19896  
         }
 19897  0
         catch (RecognitionException re) {
 19898  0
             reportError(re);
 19899  0
             recover(input,re);
 19900  
         }
 19901  
 
 19902  0
         finally {
 19903  
                 // do for sure before leaving
 19904  0
         }
 19905  0
         return retval;
 19906  
     }
 19907  
     // $ANTLR end "prefixedName"
 19908  
 
 19909  
 
 19910  0
     public static class blankNode_return extends TreeRuleReturnScope {
 19911  
         CommonTree tree;
 19912  0
         public Object getTree() { return tree; }
 19913  
     };
 19914  
 
 19915  
 
 19916  
     // $ANTLR start "blankNode"
 19917  
     // com\\googlecode\\sparkleg\\SparqlT.g:590:1: blankNode : ( BLANK_NODE_LABEL | anon );
 19918  
     public final SparqlT.blankNode_return blankNode() throws RecognitionException {
 19919  0
         SparqlT.blankNode_return retval = new SparqlT.blankNode_return();
 19920  0
         retval.start = input.LT(1);
 19921  
 
 19922  
 
 19923  0
         CommonTree root_0 = null;
 19924  
 
 19925  0
         CommonTree _first_0 = null;
 19926  0
         CommonTree _last = null;
 19927  
 
 19928  0
         CommonTree BLANK_NODE_LABEL564=null;
 19929  0
         SparqlT.anon_return anon565 =null;
 19930  
 
 19931  
 
 19932  0
         CommonTree BLANK_NODE_LABEL564_tree=null;
 19933  
 
 19934  
         try {
 19935  
             // com\\googlecode\\sparkleg\\SparqlT.g:591:5: ( BLANK_NODE_LABEL | anon )
 19936  0
             int alt148=2;
 19937  0
             switch ( input.LA(1) ) {
 19938  
             case BLANK_NODE_LABEL:
 19939  
                 {
 19940  0
                 alt148=1;
 19941  
                 }
 19942  0
                 break;
 19943  
             case OPEN_SQUARE_BRACKET:
 19944  
                 {
 19945  0
                 alt148=2;
 19946  
                 }
 19947  0
                 break;
 19948  
             default:
 19949  0
                 NoViableAltException nvae =
 19950  
                     new NoViableAltException("", 148, 0, input);
 19951  
 
 19952  0
                 throw nvae;
 19953  
 
 19954  
             }
 19955  
 
 19956  0
             switch (alt148) {
 19957  
                 case 1 :
 19958  
                     // com\\googlecode\\sparkleg\\SparqlT.g:591:7: BLANK_NODE_LABEL
 19959  
                     {
 19960  0
                     root_0 = (CommonTree)adaptor.nil();
 19961  
 
 19962  
 
 19963  0
                     _last = (CommonTree)input.LT(1);
 19964  0
                     BLANK_NODE_LABEL564=(CommonTree)match(input,BLANK_NODE_LABEL,FOLLOW_BLANK_NODE_LABEL_in_blankNode4337); 
 19965  0
                     BLANK_NODE_LABEL564_tree = (CommonTree)adaptor.dupNode(BLANK_NODE_LABEL564);
 19966  
 
 19967  
 
 19968  0
                     adaptor.addChild(root_0, BLANK_NODE_LABEL564_tree);
 19969  
 
 19970  
 
 19971  
                     }
 19972  0
                     break;
 19973  
                 case 2 :
 19974  
                     // com\\googlecode\\sparkleg\\SparqlT.g:592:7: anon
 19975  
                     {
 19976  0
                     root_0 = (CommonTree)adaptor.nil();
 19977  
 
 19978  
 
 19979  0
                     _last = (CommonTree)input.LT(1);
 19980  0
                     pushFollow(FOLLOW_anon_in_blankNode4345);
 19981  0
                     anon565=anon();
 19982  
 
 19983  0
                     state._fsp--;
 19984  
 
 19985  0
                     adaptor.addChild(root_0, anon565.getTree());
 19986  
 
 19987  
 
 19988  
                     }
 19989  
                     break;
 19990  
 
 19991  
             }
 19992  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 19993  
 
 19994  
         }
 19995  0
         catch (RecognitionException re) {
 19996  0
             reportError(re);
 19997  0
             recover(input,re);
 19998  
         }
 19999  
 
 20000  0
         finally {
 20001  
                 // do for sure before leaving
 20002  0
         }
 20003  0
         return retval;
 20004  
     }
 20005  
     // $ANTLR end "blankNode"
 20006  
 
 20007  
 
 20008  0
     public static class anon_return extends TreeRuleReturnScope {
 20009  
         CommonTree tree;
 20010  0
         public Object getTree() { return tree; }
 20011  
     };
 20012  
 
 20013  
 
 20014  
     // $ANTLR start "anon"
 20015  
     // com\\googlecode\\sparkleg\\SparqlT.g:595:1: anon : OPEN_SQUARE_BRACKET CLOSE_SQUARE_BRACKET ;
 20016  
     public final SparqlT.anon_return anon() throws RecognitionException {
 20017  0
         SparqlT.anon_return retval = new SparqlT.anon_return();
 20018  0
         retval.start = input.LT(1);
 20019  
 
 20020  
 
 20021  0
         CommonTree root_0 = null;
 20022  
 
 20023  0
         CommonTree _first_0 = null;
 20024  0
         CommonTree _last = null;
 20025  
 
 20026  0
         CommonTree OPEN_SQUARE_BRACKET566=null;
 20027  0
         CommonTree CLOSE_SQUARE_BRACKET567=null;
 20028  
 
 20029  0
         CommonTree OPEN_SQUARE_BRACKET566_tree=null;
 20030  0
         CommonTree CLOSE_SQUARE_BRACKET567_tree=null;
 20031  
 
 20032  
         try {
 20033  
             // com\\googlecode\\sparkleg\\SparqlT.g:596:5: ( OPEN_SQUARE_BRACKET CLOSE_SQUARE_BRACKET )
 20034  
             // com\\googlecode\\sparkleg\\SparqlT.g:596:7: OPEN_SQUARE_BRACKET CLOSE_SQUARE_BRACKET
 20035  
             {
 20036  0
             root_0 = (CommonTree)adaptor.nil();
 20037  
 
 20038  
 
 20039  0
             _last = (CommonTree)input.LT(1);
 20040  0
             OPEN_SQUARE_BRACKET566=(CommonTree)match(input,OPEN_SQUARE_BRACKET,FOLLOW_OPEN_SQUARE_BRACKET_in_anon4362); 
 20041  0
             OPEN_SQUARE_BRACKET566_tree = (CommonTree)adaptor.dupNode(OPEN_SQUARE_BRACKET566);
 20042  
 
 20043  
 
 20044  0
             adaptor.addChild(root_0, OPEN_SQUARE_BRACKET566_tree);
 20045  
 
 20046  
 
 20047  0
             _last = (CommonTree)input.LT(1);
 20048  0
             CLOSE_SQUARE_BRACKET567=(CommonTree)match(input,CLOSE_SQUARE_BRACKET,FOLLOW_CLOSE_SQUARE_BRACKET_in_anon4364); 
 20049  0
             CLOSE_SQUARE_BRACKET567_tree = (CommonTree)adaptor.dupNode(CLOSE_SQUARE_BRACKET567);
 20050  
 
 20051  
 
 20052  0
             adaptor.addChild(root_0, CLOSE_SQUARE_BRACKET567_tree);
 20053  
 
 20054  
 
 20055  
             }
 20056  
 
 20057  0
             retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
 20058  
 
 20059  
         }
 20060  0
         catch (RecognitionException re) {
 20061  0
             reportError(re);
 20062  0
             recover(input,re);
 20063  
         }
 20064  
 
 20065  0
         finally {
 20066  
                 // do for sure before leaving
 20067  0
         }
 20068  0
         return retval;
 20069  
     }
 20070  
     // $ANTLR end "anon"
 20071  
 
 20072  
     // Delegated rules
 20073  
 
 20074  
 
 20075  
  
 20076  
 
 20077  0
     public static final BitSet FOLLOW_QUERY_in_query53 = new BitSet(new long[]{0x0000000000000004L});
 20078  0
     public static final BitSet FOLLOW_prologue_in_query55 = new BitSet(new long[]{0x0008001000002008L,0x0000000000000000L,0x0000000040000000L});
 20079  0
     public static final BitSet FOLLOW_selectQuery_in_query57 = new BitSet(new long[]{0x0008001000002008L});
 20080  0
     public static final BitSet FOLLOW_constructQuery_in_query60 = new BitSet(new long[]{0x0008000000002008L});
 20081  0
     public static final BitSet FOLLOW_describeQuery_in_query63 = new BitSet(new long[]{0x0000000000002008L});
 20082  0
     public static final BitSet FOLLOW_askQuery_in_query66 = new BitSet(new long[]{0x0000000000000008L});
 20083  0
     public static final BitSet FOLLOW_bindingsClause_in_query70 = new BitSet(new long[]{0x0000000000000002L});
 20084  0
     public static final BitSet FOLLOW_UPDATE_in_query80 = new BitSet(new long[]{0x0000000000000004L});
 20085  0
     public static final BitSet FOLLOW_update_in_query82 = new BitSet(new long[]{0x0000000000000008L,0x0000000000000000L,0x0000000000040000L});
 20086  0
     public static final BitSet FOLLOW_PROLOGUE_in_prologue102 = new BitSet(new long[]{0x0000000000000004L});
 20087  0
     public static final BitSet FOLLOW_baseDecl_in_prologue104 = new BitSet(new long[]{0x0000000000010008L,0x0000000000000000L,0x0000000000020000L});
 20088  0
     public static final BitSet FOLLOW_prefixDecl_in_prologue107 = new BitSet(new long[]{0x0000000000000008L,0x0000000000000000L,0x0000000000020000L});
 20089  0
     public static final BitSet FOLLOW_BASE_in_baseDecl127 = new BitSet(new long[]{0x0000000000000004L});
 20090  0
     public static final BitSet FOLLOW_IRI_REF_in_baseDecl129 = new BitSet(new long[]{0x0000000000000008L});
 20091  0
     public static final BitSet FOLLOW_PREFIX_in_prefixDecl148 = new BitSet(new long[]{0x0000000000000004L});
 20092  0
     public static final BitSet FOLLOW_PNAME_NS_in_prefixDecl150 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L});
 20093  0
     public static final BitSet FOLLOW_IRI_REF_in_prefixDecl152 = new BitSet(new long[]{0x0000000000000008L});
 20094  0
     public static final BitSet FOLLOW_SELECT_in_selectQuery171 = new BitSet(new long[]{0x0000000000000004L});
 20095  0
     public static final BitSet FOLLOW_selectClause_in_selectQuery173 = new BitSet(new long[]{0x0000000000000008L,0x0400010000011040L,0x0000000000000002L,0x0000000000004000L});
 20096  0
     public static final BitSet FOLLOW_datasetClause_in_selectQuery175 = new BitSet(new long[]{0x0000000000000008L,0x0400010000011040L,0x0000000000000002L,0x0000000000004000L});
 20097  0
     public static final BitSet FOLLOW_whereClause_in_selectQuery178 = new BitSet(new long[]{0x0000000000000008L,0x0400010000011000L,0x0000000000000002L,0x0000000000004000L});
 20098  0
     public static final BitSet FOLLOW_solutionModifier_in_selectQuery181 = new BitSet(new long[]{0x0000000000000008L});
 20099  0
     public static final BitSet FOLLOW_SUBSELECT_in_subSelect200 = new BitSet(new long[]{0x0000000000000004L});
 20100  0
     public static final BitSet FOLLOW_whereClause_in_subSelect202 = new BitSet(new long[]{0x0000000000000008L,0x0400010000011040L,0x0000000000000002L,0x0000000000004000L});
 20101  0
     public static final BitSet FOLLOW_datasetClause_in_subSelect205 = new BitSet(new long[]{0x0000000000000008L,0x0400010000011040L,0x0000000000000002L});
 20102  0
     public static final BitSet FOLLOW_solutionModifier_in_subSelect208 = new BitSet(new long[]{0x0000000000000008L});
 20103  0
     public static final BitSet FOLLOW_SELECT_CLAUSE_in_selectClause232 = new BitSet(new long[]{0x0000000000000004L});
 20104  0
     public static final BitSet FOLLOW_ASTERISK_in_selectClause234 = new BitSet(new long[]{0x0000000000000008L});
 20105  0
     public static final BitSet FOLLOW_SELECT_CLAUSE_in_selectClause244 = new BitSet(new long[]{0x0000000000000004L});
 20106  0
     public static final BitSet FOLLOW_DISTINCT_in_selectClause246 = new BitSet(new long[]{0x0000000000004000L});
 20107  0
     public static final BitSet FOLLOW_ASTERISK_in_selectClause248 = new BitSet(new long[]{0x0000000000000008L});
 20108  0
     public static final BitSet FOLLOW_SELECT_CLAUSE_in_selectClause258 = new BitSet(new long[]{0x0000000000000004L});
 20109  0
     public static final BitSet FOLLOW_REDUCED_in_selectClause260 = new BitSet(new long[]{0x0000000000004000L});
 20110  0
     public static final BitSet FOLLOW_ASTERISK_in_selectClause262 = new BitSet(new long[]{0x0000000000000008L});
 20111  0
     public static final BitSet FOLLOW_SELECT_CLAUSE_in_selectClause272 = new BitSet(new long[]{0x0000000000000004L});
 20112  0
     public static final BitSet FOLLOW_selectVariables_in_selectClause274 = new BitSet(new long[]{0x0000000000000808L,0x0000000000000000L,0x0000000000000000L,0x0000000000000200L});
 20113  0
     public static final BitSet FOLLOW_SELECT_CLAUSE_in_selectClause285 = new BitSet(new long[]{0x0000000000000004L});
 20114  0
     public static final BitSet FOLLOW_DISTINCT_in_selectClause287 = new BitSet(new long[]{0x0000000000000808L,0x0000000000000000L,0x0000000000000000L,0x0000000000000200L});
 20115  0
     public static final BitSet FOLLOW_selectVariables_in_selectClause289 = new BitSet(new long[]{0x0000000000000808L,0x0000000000000000L,0x0000000000000000L,0x0000000000000200L});
 20116  0
     public static final BitSet FOLLOW_SELECT_CLAUSE_in_selectClause300 = new BitSet(new long[]{0x0000000000000004L});
 20117  0
     public static final BitSet FOLLOW_REDUCED_in_selectClause302 = new BitSet(new long[]{0x0000000000000808L,0x0000000000000000L,0x0000000000000000L,0x0000000000000200L});
 20118  0
     public static final BitSet FOLLOW_selectVariables_in_selectClause304 = new BitSet(new long[]{0x0000000000000808L,0x0000000000000000L,0x0000000000000000L,0x0000000000000200L});
 20119  0
     public static final BitSet FOLLOW_VAR_in_selectVariables324 = new BitSet(new long[]{0x0000000000000004L});
 20120  0
     public static final BitSet FOLLOW_var_in_selectVariables326 = new BitSet(new long[]{0x0000000000000008L});
 20121  0
     public static final BitSet FOLLOW_AS_in_selectVariables337 = new BitSet(new long[]{0x0000000000000004L});
 20122  0
     public static final BitSet FOLLOW_expression_in_selectVariables339 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000C00L});
 20123  0
     public static final BitSet FOLLOW_var_in_selectVariables341 = new BitSet(new long[]{0x0000000000000008L});
 20124  0
     public static final BitSet FOLLOW_CONSTRUCT_in_constructQuery362 = new BitSet(new long[]{0x0000000000000004L});
 20125  0
     public static final BitSet FOLLOW_constructTemplate_in_constructQuery364 = new BitSet(new long[]{0x0000000000000008L,0x0400010000011040L,0x0000000000000002L,0x0000000000004000L});
 20126  0
     public static final BitSet FOLLOW_datasetClause_in_constructQuery366 = new BitSet(new long[]{0x0000000000000008L,0x0400010000011040L,0x0000000000000002L,0x0000000000004000L});
 20127  0
     public static final BitSet FOLLOW_whereClause_in_constructQuery369 = new BitSet(new long[]{0x0000000000000008L,0x0400010000011000L,0x0000000000000002L});
 20128  0
     public static final BitSet FOLLOW_solutionModifier_in_constructQuery372 = new BitSet(new long[]{0x0000000000000008L});
 20129  0
     public static final BitSet FOLLOW_CONSTRUCT_in_constructQuery382 = new BitSet(new long[]{0x0000000000000004L});
 20130  0
     public static final BitSet FOLLOW_datasetClause_in_constructQuery384 = new BitSet(new long[]{0x0000000000000008L,0x0400010000011040L,0x0000000000000002L,0x0000000000004000L});
 20131  0
     public static final BitSet FOLLOW_whereClause_in_constructQuery387 = new BitSet(new long[]{0x0000000000000008L,0x0400010000011000L,0x0000000000000002L});
 20132  0
     public static final BitSet FOLLOW_solutionModifier_in_constructQuery390 = new BitSet(new long[]{0x0000000000000008L});
 20133  0
     public static final BitSet FOLLOW_DESCRIBE_in_describeQuery409 = new BitSet(new long[]{0x0000000000000004L});
 20134  0
     public static final BitSet FOLLOW_varOrIRIref_in_describeQuery411 = new BitSet(new long[]{0x0000000000004008L,0x0400010008011040L,0x0000000000000602L,0x0000000000004C00L});
 20135  0
     public static final BitSet FOLLOW_ASTERISK_in_describeQuery414 = new BitSet(new long[]{0x0000000000004008L,0x0400010000011040L,0x0000000000000002L,0x0000000000004000L});
 20136  0
     public static final BitSet FOLLOW_datasetClause_in_describeQuery417 = new BitSet(new long[]{0x0000000000000008L,0x0400010000011040L,0x0000000000000002L,0x0000000000004000L});
 20137  0
     public static final BitSet FOLLOW_whereClause_in_describeQuery420 = new BitSet(new long[]{0x0000000000000008L,0x0400010000011000L,0x0000000000000002L});
 20138  0
     public static final BitSet FOLLOW_solutionModifier_in_describeQuery423 = new BitSet(new long[]{0x0000000000000008L});
 20139  0
     public static final BitSet FOLLOW_ASK_in_askQuery442 = new BitSet(new long[]{0x0000000000000004L});
 20140  0
     public static final BitSet FOLLOW_datasetClause_in_askQuery444 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L,0x0000000000000000L,0x0000000000004000L});
 20141  0
     public static final BitSet FOLLOW_whereClause_in_askQuery447 = new BitSet(new long[]{0x0000000000000008L});
 20142  0
     public static final BitSet FOLLOW_FROM_in_datasetClause466 = new BitSet(new long[]{0x0000000000000004L});
 20143  0
     public static final BitSet FOLLOW_NAMED_in_datasetClause468 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000000000000600L});
 20144  0
     public static final BitSet FOLLOW_iriRef_in_datasetClause471 = new BitSet(new long[]{0x0000000000000008L});
 20145  0
     public static final BitSet FOLLOW_WHERE_CLAUSE_in_whereClause490 = new BitSet(new long[]{0x0000000000000004L});
 20146  0
     public static final BitSet FOLLOW_groupGraphPattern_in_whereClause492 = new BitSet(new long[]{0x0000000000000008L});
 20147  0
     public static final BitSet FOLLOW_groupClause_in_solutionModifier515 = new BitSet(new long[]{0x0000000000000002L,0x0400010000010000L,0x0000000000000002L});
 20148  0
     public static final BitSet FOLLOW_havingClause_in_solutionModifier518 = new BitSet(new long[]{0x0000000000000002L,0x0400010000000000L,0x0000000000000002L});
 20149  0
     public static final BitSet FOLLOW_orderClause_in_solutionModifier521 = new BitSet(new long[]{0x0000000000000002L,0x0400010000000000L});
 20150  0
     public static final BitSet FOLLOW_limitOffsetClauses_in_solutionModifier524 = new BitSet(new long[]{0x0000000000000002L});
 20151  0
     public static final BitSet FOLLOW_GROUP_BY_in_groupClause543 = new BitSet(new long[]{0x0000000000000004L});
 20152  0
     public static final BitSet FOLLOW_groupCondition_in_groupClause545 = new BitSet(new long[]{0x0000000000000008L,0x0000000000004000L});
 20153  0
     public static final BitSet FOLLOW_GROUP_CONDITION_in_groupCondition572 = new BitSet(new long[]{0x0000000000000004L});
 20154  0
     public static final BitSet FOLLOW_builtInCall_in_groupCondition574 = new BitSet(new long[]{0x0000000000000008L});
 20155  0
     public static final BitSet FOLLOW_GROUP_CONDITION_in_groupCondition584 = new BitSet(new long[]{0x0000000000000004L});
 20156  0
     public static final BitSet FOLLOW_functionCall_in_groupCondition586 = new BitSet(new long[]{0x0000000000000008L});
 20157  0
     public static final BitSet FOLLOW_GROUP_CONDITION_in_groupCondition596 = new BitSet(new long[]{0x0000000000000004L});
 20158  0
     public static final BitSet FOLLOW_expression_in_groupCondition598 = new BitSet(new long[]{0x0000000000000800L});
 20159  0
     public static final BitSet FOLLOW_AS_in_groupCondition601 = new BitSet(new long[]{0x0000000000000004L});
 20160  0
     public static final BitSet FOLLOW_var_in_groupCondition603 = new BitSet(new long[]{0x0000000000000008L});
 20161  0
     public static final BitSet FOLLOW_GROUP_CONDITION_in_groupCondition616 = new BitSet(new long[]{0x0000000000000004L});
 20162  0
     public static final BitSet FOLLOW_var_in_groupCondition618 = new BitSet(new long[]{0x0000000000000008L});
 20163  0
     public static final BitSet FOLLOW_HAVING_in_havingClause637 = new BitSet(new long[]{0x0000000000000004L});
 20164  0
     public static final BitSet FOLLOW_constraint_in_havingClause639 = new BitSet(new long[]{0xA640D84884C04128L,0x81E2A8EFE4CE06A1L,0x05387CF82F200100L,0x000000000002008EL});
 20165  0
     public static final BitSet FOLLOW_ORDER_BY_in_orderClause664 = new BitSet(new long[]{0x0000000000000004L});
 20166  0
     public static final BitSet FOLLOW_orderCondition_in_orderClause666 = new BitSet(new long[]{0x0000000000000008L,0x0000000000000000L,0x0000000000000004L});
 20167  0
     public static final BitSet FOLLOW_ORDER_CONDITION_in_orderCondition686 = new BitSet(new long[]{0x0000000000000004L});
 20168  0
     public static final BitSet FOLLOW_ASC_in_orderCondition688 = new BitSet(new long[]{0x8640C00000004100L,0x806020C000C80600L,0x0000000000000100L,0x0000000000000008L});
 20169  0
     public static final BitSet FOLLOW_expression_in_orderCondition690 = new BitSet(new long[]{0x0000000000000008L});
 20170  0
     public static final BitSet FOLLOW_ORDER_CONDITION_in_orderCondition700 = new BitSet(new long[]{0x0000000000000004L});
 20171  0
     public static final BitSet FOLLOW_DESC_in_orderCondition702 = new BitSet(new long[]{0x8640C00000004100L,0x806020C000C80600L,0x0000000000000100L,0x0000000000000008L});
 20172  0
     public static final BitSet FOLLOW_expression_in_orderCondition704 = new BitSet(new long[]{0x0000000000000008L});
 20173  0
     public static final BitSet FOLLOW_ORDER_CONDITION_in_orderCondition714 = new BitSet(new long[]{0x0000000000000004L});
 20174  0
     public static final BitSet FOLLOW_constraint_in_orderCondition716 = new BitSet(new long[]{0x0000000000000008L});
 20175  0
     public static final BitSet FOLLOW_ORDER_CONDITION_in_orderCondition726 = new BitSet(new long[]{0x0000000000000004L});
 20176  0
     public static final BitSet FOLLOW_var_in_orderCondition728 = new BitSet(new long[]{0x0000000000000008L});
 20177  0
     public static final BitSet FOLLOW_LIMIT_in_limitOffsetClauses752 = new BitSet(new long[]{0x0000000000000004L});
 20178  0
     public static final BitSet FOLLOW_INTEGER_in_limitOffsetClauses754 = new BitSet(new long[]{0x0000000000000008L});
 20179  0
     public static final BitSet FOLLOW_OFFSET_in_limitOffsetClauses759 = new BitSet(new long[]{0x0000000000000004L});
 20180  0
     public static final BitSet FOLLOW_INTEGER_in_limitOffsetClauses761 = new BitSet(new long[]{0x0000000000000008L});
 20181  0
     public static final BitSet FOLLOW_OFFSET_in_limitOffsetClauses773 = new BitSet(new long[]{0x0000000000000004L});
 20182  0
     public static final BitSet FOLLOW_INTEGER_in_limitOffsetClauses775 = new BitSet(new long[]{0x0000000000000008L});
 20183  0
     public static final BitSet FOLLOW_LIMIT_in_limitOffsetClauses780 = new BitSet(new long[]{0x0000000000000004L});
 20184  0
     public static final BitSet FOLLOW_INTEGER_in_limitOffsetClauses782 = new BitSet(new long[]{0x0000000000000008L});
 20185  0
     public static final BitSet FOLLOW_BINDINGS_in_bindingsClause804 = new BitSet(new long[]{0x0000000000000004L});
 20186  0
     public static final BitSet FOLLOW_var_in_bindingsClause806 = new BitSet(new long[]{0x0000000000080008L,0x0000000000000000L,0x0000000000000000L,0x0000000000000C00L});
 20187  0
     public static final BitSet FOLLOW_bindingValueList_in_bindingsClause809 = new BitSet(new long[]{0x0000000000080008L});
 20188  0
     public static final BitSet FOLLOW_BINDING_VALUE_in_bindingValueList833 = new BitSet(new long[]{0x0000000000000004L});
 20189  0
     public static final BitSet FOLLOW_bindingValue_in_bindingValueList835 = new BitSet(new long[]{0x0700E00000000008L,0x0000000008E00008L,0x0007800000000600L,0x0000000000000011L});
 20190  0
     public static final BitSet FOLLOW_iriRef_in_bindingValue859 = new BitSet(new long[]{0x0000000000000002L});
 20191  0
     public static final BitSet FOLLOW_rdfLiteral_in_bindingValue863 = new BitSet(new long[]{0x0000000000000002L});
 20192  0
     public static final BitSet FOLLOW_numericLiteral_in_bindingValue867 = new BitSet(new long[]{0x0000000000000002L});
 20193  0
     public static final BitSet FOLLOW_booleanLiteral_in_bindingValue871 = new BitSet(new long[]{0x0000000000000002L});
 20194  0
     public static final BitSet FOLLOW_UNDEF_in_bindingValue875 = new BitSet(new long[]{0x0000000000000002L});
 20195  0
     public static final BitSet FOLLOW_prologue_in_update896 = new BitSet(new long[]{0x0802028008000042L,0x0005020000100000L});
 20196  0
     public static final BitSet FOLLOW_load_in_update898 = new BitSet(new long[]{0x0802028008000042L,0x0005020000100000L});
 20197  0
     public static final BitSet FOLLOW_clear_in_update901 = new BitSet(new long[]{0x0802028008000042L,0x0005000000100000L});
 20198  0
     public static final BitSet FOLLOW_drop_in_update904 = new BitSet(new long[]{0x0802028000000042L,0x0005000000100000L});
 20199  0
     public static final BitSet FOLLOW_add_in_update907 = new BitSet(new long[]{0x0002028000000042L,0x0005000000100000L});
 20200  0
     public static final BitSet FOLLOW_move_in_update910 = new BitSet(new long[]{0x0002028000000002L,0x0005000000100000L});
 20201  0
     public static final BitSet FOLLOW_copy_in_update913 = new BitSet(new long[]{0x0002028000000002L,0x0001000000100000L});
 20202  0
     public static final BitSet FOLLOW_create_in_update916 = new BitSet(new long[]{0x0002020000000002L,0x0001000000100000L});
 20203  0
     public static final BitSet FOLLOW_insert_in_update919 = new BitSet(new long[]{0x0002000000000002L,0x0001000000100000L});
 20204  0
     public static final BitSet FOLLOW_delete_in_update922 = new BitSet(new long[]{0x0002000000000002L,0x0001000000000000L});
 20205  0
     public static final BitSet FOLLOW_modify_in_update925 = new BitSet(new long[]{0x0000000000000002L,0x0001000000000000L});
 20206  0
     public static final BitSet FOLLOW_LOAD_in_load955 = new BitSet(new long[]{0x0000000000000004L});
 20207  0
     public static final BitSet FOLLOW_SILENT_in_load957 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000020000000600L});
 20208  0
     public static final BitSet FOLLOW_iriRef_in_load960 = new BitSet(new long[]{0x0000000000000008L,0x0000000000000100L});
 20209  0
     public static final BitSet FOLLOW_graphRef_in_load962 = new BitSet(new long[]{0x0000000000000008L});
 20210  0
     public static final BitSet FOLLOW_CLEAR_in_clear986 = new BitSet(new long[]{0x0000000000000004L});
 20211  0
     public static final BitSet FOLLOW_SILENT_in_clear988 = new BitSet(new long[]{0x0001000000000080L,0x0008000000000100L,0x0000020000000000L});
 20212  0
     public static final BitSet FOLLOW_graphRefAll_in_clear991 = new BitSet(new long[]{0x0000000000000008L});
 20213  0
     public static final BitSet FOLLOW_DROP_in_drop1014 = new BitSet(new long[]{0x0000000000000004L});
 20214  0
     public static final BitSet FOLLOW_SILENT_in_drop1016 = new BitSet(new long[]{0x0001000000000080L,0x0008000000000100L,0x0000020000000000L});
 20215  0
     public static final BitSet FOLLOW_graphRefAll_in_drop1019 = new BitSet(new long[]{0x0000000000000008L});
 20216  0
     public static final BitSet FOLLOW_CREATE_in_create1039 = new BitSet(new long[]{0x0000000000000004L});
 20217  0
     public static final BitSet FOLLOW_SILENT_in_create1041 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L,0x0000020000000000L});
 20218  0
     public static final BitSet FOLLOW_graphRef_in_create1044 = new BitSet(new long[]{0x0000000000000008L});
 20219  0
     public static final BitSet FOLLOW_ADD_in_add1067 = new BitSet(new long[]{0x0000000000000004L});
 20220  0
     public static final BitSet FOLLOW_SILENT_in_add1069 = new BitSet(new long[]{0x0001000000000000L,0x0000000008000100L,0x0000020000000600L});
 20221  0
     public static final BitSet FOLLOW_graphOrDefault_in_add1072 = new BitSet(new long[]{0x0001000000000000L,0x0000000008000100L,0x0000000000000600L});
 20222  0
     public static final BitSet FOLLOW_graphOrDefault_in_add1074 = new BitSet(new long[]{0x0000000000000008L});
 20223  0
     public static final BitSet FOLLOW_MOVE_in_move1097 = new BitSet(new long[]{0x0000000000000004L});
 20224  0
     public static final BitSet FOLLOW_SILENT_in_move1099 = new BitSet(new long[]{0x0001000000000000L,0x0000000008000100L,0x0000020000000600L});
 20225  0
     public static final BitSet FOLLOW_graphOrDefault_in_move1102 = new BitSet(new long[]{0x0001000000000000L,0x0000000008000100L,0x0000000000000600L});
 20226  0
     public static final BitSet FOLLOW_graphOrDefault_in_move1104 = new BitSet(new long[]{0x0000000000000008L});
 20227  0
     public static final BitSet FOLLOW_COPY_in_copy1127 = new BitSet(new long[]{0x0000000000000004L});
 20228  0
     public static final BitSet FOLLOW_SILENT_in_copy1129 = new BitSet(new long[]{0x0001000000000000L,0x0000000008000100L,0x0000020000000600L});
 20229  0
     public static final BitSet FOLLOW_graphOrDefault_in_copy1132 = new BitSet(new long[]{0x0001000000000000L,0x0000000008000100L,0x0000000000000600L});
 20230  0
     public static final BitSet FOLLOW_graphOrDefault_in_copy1134 = new BitSet(new long[]{0x0000000000000008L});
 20231  0
     public static final BitSet FOLLOW_INSERT_in_insert1153 = new BitSet(new long[]{0x0000000000000004L});
 20232  0
     public static final BitSet FOLLOW_DATA_in_insert1155 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L,0x8000000000000000L});
 20233  0
     public static final BitSet FOLLOW_quadPattern_in_insert1157 = new BitSet(new long[]{0x0000000000000008L});
 20234  0
     public static final BitSet FOLLOW_DELETE_in_delete1182 = new BitSet(new long[]{0x0002000000000000L});
 20235  0
     public static final BitSet FOLLOW_deleteData_in_delete1185 = new BitSet(new long[]{0x0000000000000002L});
 20236  0
     public static final BitSet FOLLOW_deleteWhere_in_delete1189 = new BitSet(new long[]{0x0000000000000002L});
 20237  0
     public static final BitSet FOLLOW_DELETE_in_deleteData1208 = new BitSet(new long[]{0x0000000000000004L});
 20238  0
     public static final BitSet FOLLOW_DATA_in_deleteData1210 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L,0x8000000000000000L});
 20239  0
     public static final BitSet FOLLOW_quadPattern_in_deleteData1212 = new BitSet(new long[]{0x0000000000000008L});
 20240  0
     public static final BitSet FOLLOW_DELETE_in_deleteWhere1231 = new BitSet(new long[]{0x0000000000000004L});
 20241  0
     public static final BitSet FOLLOW_WHERE_in_deleteWhere1233 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L,0x8000000000000000L});
 20242  0
     public static final BitSet FOLLOW_quadPattern_in_deleteWhere1235 = new BitSet(new long[]{0x0000000000000008L});
 20243  0
     public static final BitSet FOLLOW_MODIFY_in_modify1258 = new BitSet(new long[]{0x0000000000000004L});
 20244  0
     public static final BitSet FOLLOW_WITH_in_modify1261 = new BitSet(new long[]{0x0000000000000004L});
 20245  0
     public static final BitSet FOLLOW_iriRef_in_modify1263 = new BitSet(new long[]{0x0000000000000008L});
 20246  0
     public static final BitSet FOLLOW_deleteClause_in_modify1266 = new BitSet(new long[]{0x0002000000000000L,0x0000000000100000L,0x0000000000000000L,0x0000000000004100L});
 20247  0
     public static final BitSet FOLLOW_insertClause_in_modify1269 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L,0x0000000000000000L,0x0000000000004100L});
 20248  0
     public static final BitSet FOLLOW_usingClause_in_modify1272 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000004100L});
 20249  0
     public static final BitSet FOLLOW_whereClause_in_modify1275 = new BitSet(new long[]{0x0000000000000008L});
 20250  0
     public static final BitSet FOLLOW_MODIFY_in_modify1285 = new BitSet(new long[]{0x0000000000000004L});
 20251  0
     public static final BitSet FOLLOW_deleteClause_in_modify1287 = new BitSet(new long[]{0x0002000000000000L,0x0000000000100000L,0x0000000000000000L,0x0000000000004100L});
 20252  0
     public static final BitSet FOLLOW_insertClause_in_modify1290 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L,0x0000000000000000L,0x0000000000004100L});
 20253  0
     public static final BitSet FOLLOW_usingClause_in_modify1293 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000004100L});
 20254  0
     public static final BitSet FOLLOW_whereClause_in_modify1296 = new BitSet(new long[]{0x0000000000000008L});
 20255  0
     public static final BitSet FOLLOW_DELETE_in_deleteClause1316 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L,0x8000000000000000L});
 20256  0
     public static final BitSet FOLLOW_quadPattern_in_deleteClause1318 = new BitSet(new long[]{0x0000000000000002L});
 20257  0
     public static final BitSet FOLLOW_INSERT_in_insertClause1341 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L,0x8000000000000000L});
 20258  0
     public static final BitSet FOLLOW_quadPattern_in_insertClause1343 = new BitSet(new long[]{0x0000000000000002L});
 20259  0
     public static final BitSet FOLLOW_USING_in_usingClause1361 = new BitSet(new long[]{0x0000000000000004L});
 20260  0
     public static final BitSet FOLLOW_NAMED_in_usingClause1363 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000000000000600L});
 20261  0
     public static final BitSet FOLLOW_iriRef_in_usingClause1366 = new BitSet(new long[]{0x0000000000000008L});
 20262  0
     public static final BitSet FOLLOW_DEFAULT_in_graphOrDefault1387 = new BitSet(new long[]{0x0000000000000002L});
 20263  0
     public static final BitSet FOLLOW_GRAPH_in_graphOrDefault1396 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000000000000600L});
 20264  0
     public static final BitSet FOLLOW_iriRef_in_graphOrDefault1399 = new BitSet(new long[]{0x0000000000000002L});
 20265  0
     public static final BitSet FOLLOW_GRAPH_in_graphRef1426 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000000000000600L});
 20266  0
     public static final BitSet FOLLOW_iriRef_in_graphRef1428 = new BitSet(new long[]{0x0000000000000002L});
 20267  0
     public static final BitSet FOLLOW_graphRef_in_graphRefAll1445 = new BitSet(new long[]{0x0000000000000002L});
 20268  0
     public static final BitSet FOLLOW_DEFAULT_in_graphRefAll1449 = new BitSet(new long[]{0x0000000000000002L});
 20269  0
     public static final BitSet FOLLOW_NAMED_in_graphRefAll1453 = new BitSet(new long[]{0x0000000000000002L});
 20270  0
     public static final BitSet FOLLOW_ALL_in_graphRefAll1457 = new BitSet(new long[]{0x0000000000000002L});
 20271  0
     public static final BitSet FOLLOW_quads_in_quadPattern1474 = new BitSet(new long[]{0x0000000000000002L});
 20272  0
     public static final BitSet FOLLOW_triplesTemplate_in_quads1495 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000100L});
 20273  0
     public static final BitSet FOLLOW_quadsNotTriples_in_quads1499 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000100L,0x8000000000000000L});
 20274  0
     public static final BitSet FOLLOW_triplesTemplate_in_quads1501 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000100L});
 20275  0
     public static final BitSet FOLLOW_GRAPH_in_quadsNotTriples1526 = new BitSet(new long[]{0x0000000000000004L});
 20276  0
     public static final BitSet FOLLOW_varOrIRIref_in_quadsNotTriples1528 = new BitSet(new long[]{0x0000000000000008L,0x0000000000000000L,0x8000000000000000L});
 20277  0
     public static final BitSet FOLLOW_triplesTemplate_in_quadsNotTriples1530 = new BitSet(new long[]{0x0000000000000008L});
 20278  0
     public static final BitSet FOLLOW_TRIPLES_TEMPLATE_in_triplesTemplate1554 = new BitSet(new long[]{0x0000000000000004L});
 20279  0
     public static final BitSet FOLLOW_triplesSameSubject_in_triplesTemplate1556 = new BitSet(new long[]{0x0000000000000008L,0x0000000000000000L,0x4000000000000000L});
 20280  0
     public static final BitSet FOLLOW_GROUP_GRAPH_PATTERN_in_groupGraphPattern1576 = new BitSet(new long[]{0x0000000000000004L});
 20281  0
     public static final BitSet FOLLOW_groupGraphPatternSub_in_groupGraphPattern1578 = new BitSet(new long[]{0x0000000000000008L});
 20282  0
     public static final BitSet FOLLOW_GROUP_GRAPH_PATTERN_in_groupGraphPattern1588 = new BitSet(new long[]{0x0000000000000004L});
 20283  0
     public static final BitSet FOLLOW_subSelect_in_groupGraphPattern1590 = new BitSet(new long[]{0x0000000000000008L});
 20284  0
     public static final BitSet FOLLOW_GROUP_GRAPH_PATTERN_in_groupGraphPattern1600 = new BitSet(new long[]{0x0000000000000004L});
 20285  0
     public static final BitSet FOLLOW_GROUP_GRAPH_PATTERN_in_groupGraphPattern1602 = new BitSet(new long[]{0x0000000000000008L});
 20286  0
     public static final BitSet FOLLOW_triplesBlock_in_groupGraphPatternSub1620 = new BitSet(new long[]{0x0000000000020002L,0x4000400000008110L,0x0000000400000000L,0x0000000000000020L});
 20287  0
     public static final BitSet FOLLOW_groupGraphPatternSubDetail_in_groupGraphPatternSub1622 = new BitSet(new long[]{0x0000000000020002L,0x4000400000008110L,0x0000000400000000L,0x0000000000000020L});
 20288  0
     public static final BitSet FOLLOW_groupGraphPatternSubDetail_in_groupGraphPatternSub1631 = new BitSet(new long[]{0x0000000000020002L,0x4000400000008110L,0x0000000400000000L,0x0000000000000020L});
 20289  0
     public static final BitSet FOLLOW_graphPatternNotTriples_in_groupGraphPatternSubDetail1652 = new BitSet(new long[]{0x0080000000000002L,0x0000000000000000L,0x4000000000000000L});
 20290  0
     public static final BitSet FOLLOW_DOT_in_groupGraphPatternSubDetail1654 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x4000000000000000L});
 20291  0
     public static final BitSet FOLLOW_triplesBlock_in_groupGraphPatternSubDetail1659 = new BitSet(new long[]{0x0000000000000002L});
 20292  0
     public static final BitSet FOLLOW_triplesSameSubjectPath_in_triplesBlock1681 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x4000000000000000L});
 20293  0
     public static final BitSet FOLLOW_groupOrUnionGraphPattern_in_graphPatternNotTriples1699 = new BitSet(new long[]{0x0000000000000002L});
 20294  0
     public static final BitSet FOLLOW_optionalGraphPattern_in_graphPatternNotTriples1703 = new BitSet(new long[]{0x0000000000000002L});
 20295  0
     public static final BitSet FOLLOW_minusGraphPattern_in_graphPatternNotTriples1707 = new BitSet(new long[]{0x0000000000000002L});
 20296  0
     public static final BitSet FOLLOW_graphGraphPattern_in_graphPatternNotTriples1711 = new BitSet(new long[]{0x0000000000000002L});
 20297  0
     public static final BitSet FOLLOW_serviceGraphPattern_in_graphPatternNotTriples1715 = new BitSet(new long[]{0x0000000000000002L});
 20298  0
     public static final BitSet FOLLOW_filter_in_graphPatternNotTriples1719 = new BitSet(new long[]{0x0000000000000002L});
 20299  0
     public static final BitSet FOLLOW_bind_in_graphPatternNotTriples1723 = new BitSet(new long[]{0x0000000000000002L});
 20300  0
     public static final BitSet FOLLOW_OPTIONAL_in_optionalGraphPattern1741 = new BitSet(new long[]{0x0000000000000004L});
 20301  0
     public static final BitSet FOLLOW_groupGraphPattern_in_optionalGraphPattern1743 = new BitSet(new long[]{0x0000000000000008L});
 20302  0
     public static final BitSet FOLLOW_GRAPH_in_graphGraphPattern1762 = new BitSet(new long[]{0x0000000000000004L});
 20303  0
     public static final BitSet FOLLOW_varOrIRIref_in_graphGraphPattern1764 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L});
 20304  0
     public static final BitSet FOLLOW_groupGraphPattern_in_graphGraphPattern1766 = new BitSet(new long[]{0x0000000000000008L});
 20305  0
     public static final BitSet FOLLOW_SERVICE_in_serviceGraphPattern1785 = new BitSet(new long[]{0x0000000000000004L});
 20306  0
     public static final BitSet FOLLOW_SILENT_in_serviceGraphPattern1787 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000000000000600L,0x0000000000000C00L});
 20307  0
     public static final BitSet FOLLOW_varOrIRIref_in_serviceGraphPattern1790 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L});
 20308  0
     public static final BitSet FOLLOW_groupGraphPattern_in_serviceGraphPattern1792 = new BitSet(new long[]{0x0000000000000008L});
 20309  0
     public static final BitSet FOLLOW_BIND_in_bind1815 = new BitSet(new long[]{0x0000000000000004L});
 20310  0
     public static final BitSet FOLLOW_expression_in_bind1817 = new BitSet(new long[]{0x0000000000000800L});
 20311  0
     public static final BitSet FOLLOW_AS_in_bind1820 = new BitSet(new long[]{0x0000000000000004L});
 20312  0
     public static final BitSet FOLLOW_var_in_bind1822 = new BitSet(new long[]{0x0000000000000008L});
 20313  0
     public static final BitSet FOLLOW_MINUS_KEYWORD_in_minusGraphPattern1848 = new BitSet(new long[]{0x0000000000000004L});
 20314  0
     public static final BitSet FOLLOW_groupGraphPattern_in_minusGraphPattern1850 = new BitSet(new long[]{0x0000000000000008L});
 20315  0
     public static final BitSet FOLLOW_UNION_in_groupOrUnionGraphPattern1869 = new BitSet(new long[]{0x0000000000000004L});
 20316  0
     public static final BitSet FOLLOW_groupGraphPattern_in_groupOrUnionGraphPattern1871 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L});
 20317  0
     public static final BitSet FOLLOW_groupGraphPattern_in_groupOrUnionGraphPattern1873 = new BitSet(new long[]{0x0000000000000008L});
 20318  0
     public static final BitSet FOLLOW_groupGraphPattern_in_groupOrUnionGraphPattern1882 = new BitSet(new long[]{0x0000000000000002L});
 20319  0
     public static final BitSet FOLLOW_FILTER_in_filter1900 = new BitSet(new long[]{0x0000000000000004L});
 20320  0
     public static final BitSet FOLLOW_constraint_in_filter1902 = new BitSet(new long[]{0x0000000000000008L});
 20321  0
     public static final BitSet FOLLOW_expression_in_constraint1920 = new BitSet(new long[]{0x0000000000000002L});
 20322  0
     public static final BitSet FOLLOW_builtInCall_in_constraint1928 = new BitSet(new long[]{0x0000000000000002L});
 20323  0
     public static final BitSet FOLLOW_functionCall_in_constraint1936 = new BitSet(new long[]{0x0000000000000002L});
 20324  0
     public static final BitSet FOLLOW_FUNCTION_in_functionCall1954 = new BitSet(new long[]{0x0000000000000004L});
 20325  0
     public static final BitSet FOLLOW_iriRef_in_functionCall1956 = new BitSet(new long[]{0x0000000000000400L});
 20326  0
     public static final BitSet FOLLOW_ARG_LIST_in_functionCall1959 = new BitSet(new long[]{0x0000000000000004L});
 20327  0
     public static final BitSet FOLLOW_argList_in_functionCall1961 = new BitSet(new long[]{0x0000000000000008L});
 20328  0
     public static final BitSet FOLLOW_nil_in_argList1980 = new BitSet(new long[]{0x0000000000000002L});
 20329  0
     public static final BitSet FOLLOW_DISTINCT_in_argList1988 = new BitSet(new long[]{0x8640C00000004102L,0x806020C000C80600L,0x0000000000000100L,0x0000000000000008L});
 20330  0
     public static final BitSet FOLLOW_expression_in_argList1991 = new BitSet(new long[]{0x8640C00000004102L,0x806020C000C80600L,0x0000000000000100L,0x0000000000000008L});
 20331  0
     public static final BitSet FOLLOW_EXPRESSION_LIST_in_expressionList2010 = new BitSet(new long[]{0x0000000000000004L});
 20332  0
     public static final BitSet FOLLOW_expression_in_expressionList2012 = new BitSet(new long[]{0x8640C00000004108L,0x806020C000C80600L,0x0000000000000100L,0x0000000000000008L});
 20333  0
     public static final BitSet FOLLOW_EXPRESSION_LIST_in_expressionList2023 = new BitSet(new long[]{0x0000000000000004L});
 20334  0
     public static final BitSet FOLLOW_nil_in_expressionList2025 = new BitSet(new long[]{0x0000000000000008L});
 20335  0
     public static final BitSet FOLLOW_CONSTRUCT_TRIPLES_in_constructTemplate2045 = new BitSet(new long[]{0x0000000000000004L});
 20336  0
     public static final BitSet FOLLOW_constructTriples_in_constructTemplate2047 = new BitSet(new long[]{0x0000000000000008L});
 20337  0
     public static final BitSet FOLLOW_triplesSameSubject_in_constructTriples2066 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x4000000000000000L});
 20338  0
     public static final BitSet FOLLOW_TRIPLES_SAME_SUBJECT_in_triplesSameSubject2085 = new BitSet(new long[]{0x0000000000000004L});
 20339  0
     public static final BitSet FOLLOW_SUBJECT_in_triplesSameSubject2088 = new BitSet(new long[]{0x0000000000000004L});
 20340  0
     public static final BitSet FOLLOW_varOrTerm_in_triplesSameSubject2090 = new BitSet(new long[]{0x0000000000000008L});
 20341  0
     public static final BitSet FOLLOW_propertyListNotEmpty_in_triplesSameSubject2093 = new BitSet(new long[]{0x0000000000000008L});
 20342  0
     public static final BitSet FOLLOW_TRIPLES_SAME_SUBJECT_in_triplesSameSubject2103 = new BitSet(new long[]{0x0000000000000004L});
 20343  0
     public static final BitSet FOLLOW_triplesNode_in_triplesSameSubject2105 = new BitSet(new long[]{0x0000000000000008L,0x0000000000000000L,0x0000000000010000L});
 20344  0
     public static final BitSet FOLLOW_propertyListNotEmpty_in_triplesSameSubject2107 = new BitSet(new long[]{0x0000000000000008L});
 20345  0
     public static final BitSet FOLLOW_propertyListNotEmptyDetails_in_propertyListNotEmpty2139 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000010000L});
 20346  0
     public static final BitSet FOLLOW_PREDICATE_in_propertyListNotEmptyDetails2158 = new BitSet(new long[]{0x0000000000000004L});
 20347  0
     public static final BitSet FOLLOW_verb_in_propertyListNotEmptyDetails2163 = new BitSet(new long[]{0x0000000000000000L,0x0200000000000000L});
 20348  0
     public static final BitSet FOLLOW_objectList_in_propertyListNotEmptyDetails2167 = new BitSet(new long[]{0x0000000000000008L});
 20349  0
     public static final BitSet FOLLOW_OBJECT_in_objectList2187 = new BitSet(new long[]{0x0000000000000004L});
 20350  0
     public static final BitSet FOLLOW_graphNode_in_objectList2189 = new BitSet(new long[]{0x0000000000000008L});
 20351  0
     public static final BitSet FOLLOW_varOrIRIref_in_verb2209 = new BitSet(new long[]{0x0000000000000002L});
 20352  0
     public static final BitSet FOLLOW_A_in_verb2217 = new BitSet(new long[]{0x0000000000000002L});
 20353  0
     public static final BitSet FOLLOW_path_in_verb2225 = new BitSet(new long[]{0x0000000000000002L});
 20354  0
     public static final BitSet FOLLOW_TRIPLES_SAME_SUBJECT_in_triplesSameSubjectPath2243 = new BitSet(new long[]{0x0000000000000004L});
 20355  0
     public static final BitSet FOLLOW_SUBJECT_in_triplesSameSubjectPath2246 = new BitSet(new long[]{0x0000000000000004L});
 20356  0
     public static final BitSet FOLLOW_varOrTerm_in_triplesSameSubjectPath2248 = new BitSet(new long[]{0x0000000000000008L});
 20357  0
     public static final BitSet FOLLOW_propertyListNotEmpty_in_triplesSameSubjectPath2251 = new BitSet(new long[]{0x0000000000000008L});
 20358  0
     public static final BitSet FOLLOW_TRIPLES_SAME_SUBJECT_in_triplesSameSubjectPath2261 = new BitSet(new long[]{0x0000000000000004L});
 20359  0
     public static final BitSet FOLLOW_triplesNode_in_triplesSameSubjectPath2264 = new BitSet(new long[]{0x0000000000000008L,0x0000000000000000L,0x0000000000010000L});
 20360  0
     public static final BitSet FOLLOW_propertyListNotEmpty_in_triplesSameSubjectPath2266 = new BitSet(new long[]{0x0000000000000008L});
 20361  0
     public static final BitSet FOLLOW_PATH_in_path2290 = new BitSet(new long[]{0x0000000000000004L});
 20362  0
     public static final BitSet FOLLOW_pathSequence_in_path2292 = new BitSet(new long[]{0x0000000000000008L,0x0000000000000000L,0x0000000000000040L});
 20363  0
     public static final BitSet FOLLOW_PATH_SEQUENCE_in_pathSequence2313 = new BitSet(new long[]{0x0000000000000004L});
 20364  0
     public static final BitSet FOLLOW_pathEltOrInverse_in_pathSequence2315 = new BitSet(new long[]{0x0000000000000008L,0x0000000002000000L,0x0000000000000020L});
 20365  0
     public static final BitSet FOLLOW_INVERSE_in_pathEltOrInverse2338 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000020L});
 20366  0
     public static final BitSet FOLLOW_pathElt_in_pathEltOrInverse2341 = new BitSet(new long[]{0x0000000000000002L});
 20367  0
     public static final BitSet FOLLOW_pathPrimary_in_pathElt2366 = new BitSet(new long[]{0x0000000000004002L,0x1000000000000000L,0x0000000000100100L});
 20368  0
     public static final BitSet FOLLOW_pathMod_in_pathElt2368 = new BitSet(new long[]{0x0000000000000002L});
 20369  0
     public static final BitSet FOLLOW_ASTERISK_in_pathMod2391 = new BitSet(new long[]{0x0000000000000002L});
 20370  0
     public static final BitSet FOLLOW_QUESTION_MARK_in_pathMod2395 = new BitSet(new long[]{0x0000000000000002L});
 20371  0
     public static final BitSet FOLLOW_PLUS_in_pathMod2399 = new BitSet(new long[]{0x0000000000000002L});
 20372  0
     public static final BitSet FOLLOW_OPEN_CURLY_BRACE_in_pathMod2403 = new BitSet(new long[]{0x0000000200000000L,0x0000000000200000L});
 20373  0
     public static final BitSet FOLLOW_INTEGER_in_pathMod2406 = new BitSet(new long[]{0x0000000220000000L});
 20374  0
     public static final BitSet FOLLOW_COMMA_in_pathMod2409 = new BitSet(new long[]{0x0000000020000000L,0x0000000000200000L});
 20375  0
     public static final BitSet FOLLOW_CLOSE_CURLY_BRACE_in_pathMod2412 = new BitSet(new long[]{0x0000000000000002L});
 20376  0
     public static final BitSet FOLLOW_INTEGER_in_pathMod2416 = new BitSet(new long[]{0x0000000020000000L});
 20377  0
     public static final BitSet FOLLOW_CLOSE_CURLY_BRACE_in_pathMod2418 = new BitSet(new long[]{0x0000000000000002L});
 20378  0
     public static final BitSet FOLLOW_CLOSE_CURLY_BRACE_in_pathMod2423 = new BitSet(new long[]{0x0000000000000002L});
 20379  0
     public static final BitSet FOLLOW_COMMA_in_pathMod2428 = new BitSet(new long[]{0x0000000000000000L,0x0000000000200000L});
 20380  0
     public static final BitSet FOLLOW_INTEGER_in_pathMod2430 = new BitSet(new long[]{0x0000000020000000L});
 20381  0
     public static final BitSet FOLLOW_CLOSE_CURLY_BRACE_in_pathMod2432 = new BitSet(new long[]{0x0000000000000002L});
 20382  0
     public static final BitSet FOLLOW_PATH_PRIMARY_in_pathPrimary2452 = new BitSet(new long[]{0x0000000000000004L});
 20383  0
     public static final BitSet FOLLOW_iriRef_in_pathPrimary2454 = new BitSet(new long[]{0x0000000000000008L});
 20384  0
     public static final BitSet FOLLOW_PATH_PRIMARY_in_pathPrimary2464 = new BitSet(new long[]{0x0000000000000004L});
 20385  0
     public static final BitSet FOLLOW_A_in_pathPrimary2466 = new BitSet(new long[]{0x0000000000000008L});
 20386  0
     public static final BitSet FOLLOW_PATH_PRIMARY_in_pathPrimary2476 = new BitSet(new long[]{0x0000000000000004L});
 20387  0
     public static final BitSet FOLLOW_NEGATION_in_pathPrimary2478 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000010L});
 20388  0
     public static final BitSet FOLLOW_pathNegatedPropertySet_in_pathPrimary2480 = new BitSet(new long[]{0x0000000000000008L});
 20389  0
     public static final BitSet FOLLOW_PATH_PRIMARY_in_pathPrimary2490 = new BitSet(new long[]{0x0000000000000004L});
 20390  0
     public static final BitSet FOLLOW_path_in_pathPrimary2492 = new BitSet(new long[]{0x0000000000000008L});
 20391  0
     public static final BitSet FOLLOW_PATH_NEGATED_in_pathNegatedPropertySet2511 = new BitSet(new long[]{0x0000000000000004L});
 20392  0
     public static final BitSet FOLLOW_pathOneInPropertySet_in_pathNegatedPropertySet2513 = new BitSet(new long[]{0x0000000000000018L,0x000000000A000000L,0x0000000000000600L});
 20393  0
     public static final BitSet FOLLOW_INVERSE_in_pathOneInPropertySet2535 = new BitSet(new long[]{0x0000000000000010L,0x0000000008000000L,0x0000000000000600L});
 20394  0
     public static final BitSet FOLLOW_iriRef_in_pathOneInPropertySet2539 = new BitSet(new long[]{0x0000000000000002L});
 20395  0
     public static final BitSet FOLLOW_A_in_pathOneInPropertySet2543 = new BitSet(new long[]{0x0000000000000002L});
 20396  0
     public static final BitSet FOLLOW_COLLECTION_in_triplesNode2563 = new BitSet(new long[]{0x0000000000000004L});
 20397  0
     public static final BitSet FOLLOW_graphNode_in_triplesNode2565 = new BitSet(new long[]{0x0700E00100300008L,0x2800000008E00008L,0x2007800000000600L,0x0000000000000C01L});
 20398  0
     public static final BitSet FOLLOW_TRIPLES_NODE_in_triplesNode2576 = new BitSet(new long[]{0x0000000000000004L});
 20399  0
     public static final BitSet FOLLOW_propertyListNotEmpty_in_triplesNode2578 = new BitSet(new long[]{0x0000000000000008L});
 20400  0
     public static final BitSet FOLLOW_varOrTerm_in_graphNode2596 = new BitSet(new long[]{0x0000000000000002L});
 20401  0
     public static final BitSet FOLLOW_triplesNode_in_graphNode2600 = new BitSet(new long[]{0x0000000000000002L});
 20402  0
     public static final BitSet FOLLOW_var_in_varOrTerm2617 = new BitSet(new long[]{0x0000000000000002L});
 20403  0
     public static final BitSet FOLLOW_graphTerm_in_varOrTerm2621 = new BitSet(new long[]{0x0000000000000002L});
 20404  0
     public static final BitSet FOLLOW_BLANK_NODE_in_varOrTerm2625 = new BitSet(new long[]{0x0000000000000002L});
 20405  0
     public static final BitSet FOLLOW_var_in_varOrIRIref2642 = new BitSet(new long[]{0x0000000000000002L});
 20406  0
     public static final BitSet FOLLOW_iriRef_in_varOrIRIref2646 = new BitSet(new long[]{0x0000000000000002L});
 20407  0
     public static final BitSet FOLLOW_iriRef_in_graphTerm2684 = new BitSet(new long[]{0x0000000000000002L});
 20408  0
     public static final BitSet FOLLOW_rdfLiteral_in_graphTerm2692 = new BitSet(new long[]{0x0000000000000002L});
 20409  0
     public static final BitSet FOLLOW_numericLiteral_in_graphTerm2700 = new BitSet(new long[]{0x0000000000000002L});
 20410  0
     public static final BitSet FOLLOW_booleanLiteral_in_graphTerm2708 = new BitSet(new long[]{0x0000000000000002L});
 20411  0
     public static final BitSet FOLLOW_blankNode_in_graphTerm2716 = new BitSet(new long[]{0x0000000000000002L});
 20412  0
     public static final BitSet FOLLOW_nil_in_graphTerm2724 = new BitSet(new long[]{0x0000000000000002L});
 20413  0
     public static final BitSet FOLLOW_OPEN_BRACE_in_nil2745 = new BitSet(new long[]{0x0000000010000000L});
 20414  0
     public static final BitSet FOLLOW_CLOSE_BRACE_in_nil2747 = new BitSet(new long[]{0x0000000000000002L});
 20415  0
     public static final BitSet FOLLOW_OR_in_expression2765 = new BitSet(new long[]{0x0000000000000004L});
 20416  0
     public static final BitSet FOLLOW_expression_in_expression2767 = new BitSet(new long[]{0x8640C00000004100L,0x806020C000C80600L,0x0000000000000100L,0x0000000000000008L});
 20417  0
     public static final BitSet FOLLOW_expression_in_expression2769 = new BitSet(new long[]{0x0000000000000008L});
 20418  0
     public static final BitSet FOLLOW_AND_in_expression2779 = new BitSet(new long[]{0x0000000000000004L});
 20419  0
     public static final BitSet FOLLOW_expression_in_expression2781 = new BitSet(new long[]{0x8640C00000004100L,0x806020C000C80600L,0x0000000000000100L,0x0000000000000008L});
 20420  0
     public static final BitSet FOLLOW_expression_in_expression2783 = new BitSet(new long[]{0x0000000000000008L});
 20421  0
     public static final BitSet FOLLOW_EQUAL_in_expression2793 = new BitSet(new long[]{0x0000000000000004L});
 20422  0
     public static final BitSet FOLLOW_expression_in_expression2795 = new BitSet(new long[]{0x8640C00000004100L,0x806020C000C80600L,0x0000000000000100L,0x0000000000000008L});
 20423  0
     public static final BitSet FOLLOW_expression_in_expression2797 = new BitSet(new long[]{0x0000000000000008L});
 20424  0
     public static final BitSet FOLLOW_NOT_EQUAL_in_expression2809 = new BitSet(new long[]{0x0000000000000004L});
 20425  0
     public static final BitSet FOLLOW_expression_in_expression2811 = new BitSet(new long[]{0x8640C00000004100L,0x806020C000C80600L,0x0000000000000100L,0x0000000000000008L});
 20426  0
     public static final BitSet FOLLOW_expression_in_expression2813 = new BitSet(new long[]{0x0000000000000008L});
 20427  0
     public static final BitSet FOLLOW_LESS_in_expression2823 = new BitSet(new long[]{0x0000000000000004L});
 20428  0
     public static final BitSet FOLLOW_expression_in_expression2825 = new BitSet(new long[]{0x8640C00000004100L,0x806020C000C80600L,0x0000000000000100L,0x0000000000000008L});
 20429  0
     public static final BitSet FOLLOW_expression_in_expression2827 = new BitSet(new long[]{0x0000000000000008L});
 20430  0
     public static final BitSet FOLLOW_GREATER_in_expression2837 = new BitSet(new long[]{0x0000000000000004L});
 20431  0
     public static final BitSet FOLLOW_expression_in_expression2839 = new BitSet(new long[]{0x8640C00000004100L,0x806020C000C80600L,0x0000000000000100L,0x0000000000000008L});
 20432  0
     public static final BitSet FOLLOW_expression_in_expression2841 = new BitSet(new long[]{0x0000000000000008L});
 20433  0
     public static final BitSet FOLLOW_LESS_EQUAL_in_expression2851 = new BitSet(new long[]{0x0000000000000004L});
 20434  0
     public static final BitSet FOLLOW_expression_in_expression2853 = new BitSet(new long[]{0x8640C00000004100L,0x806020C000C80600L,0x0000000000000100L,0x0000000000000008L});
 20435  0
     public static final BitSet FOLLOW_expression_in_expression2855 = new BitSet(new long[]{0x0000000000000008L});
 20436  0
     public static final BitSet FOLLOW_GREATER_EQUAL_in_expression2865 = new BitSet(new long[]{0x0000000000000004L});
 20437  0
     public static final BitSet FOLLOW_expression_in_expression2867 = new BitSet(new long[]{0x8640C00000004100L,0x806020C000C80600L,0x0000000000000100L,0x0000000000000008L});
 20438  0
     public static final BitSet FOLLOW_expression_in_expression2869 = new BitSet(new long[]{0x0000000000000008L});
 20439  0
     public static final BitSet FOLLOW_IN_in_expression2881 = new BitSet(new long[]{0x0000000000000004L});
 20440  0
     public static final BitSet FOLLOW_expression_in_expression2883 = new BitSet(new long[]{0x8640C00000004100L,0x806020C000C80600L,0x0000000000000100L,0x0000000000000008L});
 20441  0
     public static final BitSet FOLLOW_expression_in_expression2885 = new BitSet(new long[]{0x0000000000000008L});
 20442  0
     public static final BitSet FOLLOW_NOT_in_expression2895 = new BitSet(new long[]{0x0000000000000004L});
 20443  0
     public static final BitSet FOLLOW_IN_in_expression2897 = new BitSet(new long[]{0x8640C00000004100L,0x806020C000C80600L,0x0000000000000100L,0x0000000000000008L});
 20444  0
     public static final BitSet FOLLOW_expression_in_expression2899 = new BitSet(new long[]{0x8640C00000004100L,0x806020C000C80600L,0x0000000000000100L,0x0000000000000008L});
 20445  0
     public static final BitSet FOLLOW_expression_in_expression2901 = new BitSet(new long[]{0x0000000000000008L});
 20446  0
     public static final BitSet FOLLOW_PLUS_in_expression2911 = new BitSet(new long[]{0x0000000000000004L});
 20447  0
     public static final BitSet FOLLOW_expression_in_expression2913 = new BitSet(new long[]{0x8640C00000004100L,0x806020C000C80600L,0x0000000000000100L,0x0000000000000008L});
 20448  0
     public static final BitSet FOLLOW_expression_in_expression2915 = new BitSet(new long[]{0x0000000000000008L});
 20449  0
     public static final BitSet FOLLOW_MINUS_in_expression2925 = new BitSet(new long[]{0x0000000000000004L});
 20450  0
     public static final BitSet FOLLOW_expression_in_expression2927 = new BitSet(new long[]{0x8640C00000004100L,0x806020C000C80600L,0x0000000000000100L,0x0000000000000008L});
 20451  0
     public static final BitSet FOLLOW_expression_in_expression2929 = new BitSet(new long[]{0x0000000000000008L});
 20452  0
     public static final BitSet FOLLOW_ASTERISK_in_expression2940 = new BitSet(new long[]{0x0000000000000004L});
 20453  0
     public static final BitSet FOLLOW_expression_in_expression2942 = new BitSet(new long[]{0x8640C00000004100L,0x806020C000C80600L,0x0000000000000100L,0x0000000000000008L});
 20454  0
     public static final BitSet FOLLOW_expression_in_expression2944 = new BitSet(new long[]{0x0000000000000008L});
 20455  0
     public static final BitSet FOLLOW_DIVIDE_in_expression2954 = new BitSet(new long[]{0x0000000000000004L});
 20456  0
     public static final BitSet FOLLOW_expression_in_expression2956 = new BitSet(new long[]{0x8640C00000004100L,0x806020C000C80600L,0x0000000000000100L,0x0000000000000008L});
 20457  0
     public static final BitSet FOLLOW_expression_in_expression2958 = new BitSet(new long[]{0x0000000000000008L});
 20458  0
     public static final BitSet FOLLOW_numericLiteralPositive_in_expression2967 = new BitSet(new long[]{0x0000000000000002L});
 20459  0
     public static final BitSet FOLLOW_numericLiteralNegative_in_expression2975 = new BitSet(new long[]{0x0000000000000002L});
 20460  0
     public static final BitSet FOLLOW_unaryExpression_in_expression2983 = new BitSet(new long[]{0x0000000000000002L});
 20461  0
     public static final BitSet FOLLOW_UNARY_in_unaryExpression3006 = new BitSet(new long[]{0x0000000000000004L});
 20462  0
     public static final BitSet FOLLOW_NEGATION_in_unaryExpression3008 = new BitSet(new long[]{0x2700F94885C08020L,0x01829C2FE4E620A9L,0x073FFCF83F200000L,0x0000000000020C87L});
 20463  0
     public static final BitSet FOLLOW_primaryExpression_in_unaryExpression3010 = new BitSet(new long[]{0x0000000000000008L});
 20464  0
     public static final BitSet FOLLOW_UNARY_in_unaryExpression3020 = new BitSet(new long[]{0x0000000000000004L});
 20465  0
     public static final BitSet FOLLOW_PLUS_in_unaryExpression3022 = new BitSet(new long[]{0x2700F94885C08020L,0x01829C2FE4E620A9L,0x073FFCF83F200000L,0x0000000000020C87L});
 20466  0
     public static final BitSet FOLLOW_primaryExpression_in_unaryExpression3024 = new BitSet(new long[]{0x0000000000000008L});
 20467  0
     public static final BitSet FOLLOW_UNARY_in_unaryExpression3034 = new BitSet(new long[]{0x0000000000000004L});
 20468  0
     public static final BitSet FOLLOW_MINUS_in_unaryExpression3036 = new BitSet(new long[]{0x2700F94885C08020L,0x01829C2FE4E620A9L,0x073FFCF83F200000L,0x0000000000020C87L});
 20469  0
     public static final BitSet FOLLOW_primaryExpression_in_unaryExpression3038 = new BitSet(new long[]{0x0000000000000008L});
 20470  0
     public static final BitSet FOLLOW_UNARY_in_unaryExpression3048 = new BitSet(new long[]{0x0000000000000004L});
 20471  0
     public static final BitSet FOLLOW_primaryExpression_in_unaryExpression3050 = new BitSet(new long[]{0x0000000000000008L});
 20472  0
     public static final BitSet FOLLOW_brackettedExpression_in_primaryExpression3069 = new BitSet(new long[]{0x0000000000000002L});
 20473  0
     public static final BitSet FOLLOW_builtInCall_in_primaryExpression3073 = new BitSet(new long[]{0x0000000000000002L});
 20474  0
     public static final BitSet FOLLOW_iriRefOrFunction_in_primaryExpression3077 = new BitSet(new long[]{0x0000000000000002L});
 20475  0
     public static final BitSet FOLLOW_rdfLiteral_in_primaryExpression3081 = new BitSet(new long[]{0x0000000000000002L});
 20476  0
     public static final BitSet FOLLOW_numericLiteral_in_primaryExpression3085 = new BitSet(new long[]{0x0000000000000002L});
 20477  0
     public static final BitSet FOLLOW_booleanLiteral_in_primaryExpression3089 = new BitSet(new long[]{0x0000000000000002L});
 20478  0
     public static final BitSet FOLLOW_var_in_primaryExpression3093 = new BitSet(new long[]{0x0000000000000002L});
 20479  0
     public static final BitSet FOLLOW_aggregate_in_primaryExpression3097 = new BitSet(new long[]{0x0000000000000002L});
 20480  0
     public static final BitSet FOLLOW_BRACKETTED_EXPRESSION_in_brackettedExpression3115 = new BitSet(new long[]{0x0000000000000004L});
 20481  0
     public static final BitSet FOLLOW_expression_in_brackettedExpression3119 = new BitSet(new long[]{0x0000000000000008L});
 20482  0
     public static final BitSet FOLLOW_STR_in_builtInCall3138 = new BitSet(new long[]{0x0000000000000004L});
 20483  0
     public static final BitSet FOLLOW_expression_in_builtInCall3140 = new BitSet(new long[]{0x0000000000000008L});
 20484  0
     public static final BitSet FOLLOW_LANG_in_builtInCall3150 = new BitSet(new long[]{0x0000000000000004L});
 20485  0
     public static final BitSet FOLLOW_expression_in_builtInCall3152 = new BitSet(new long[]{0x0000000000000008L});
 20486  0
     public static final BitSet FOLLOW_LANGMATCHES_in_builtInCall3162 = new BitSet(new long[]{0x0000000000000004L});
 20487  0
     public static final BitSet FOLLOW_expression_in_builtInCall3164 = new BitSet(new long[]{0x8640C00000004108L,0x806020C000C80600L,0x0000000000000100L,0x0000000000000008L});
 20488  0
     public static final BitSet FOLLOW_DATATYPE_in_builtInCall3175 = new BitSet(new long[]{0x0000000000000004L});
 20489  0
     public static final BitSet FOLLOW_expression_in_builtInCall3177 = new BitSet(new long[]{0x0000000000000008L});
 20490  0
     public static final BitSet FOLLOW_BOUND_in_builtInCall3187 = new BitSet(new long[]{0x0000000000000004L});
 20491  0
     public static final BitSet FOLLOW_var_in_builtInCall3189 = new BitSet(new long[]{0x0000000000000008L});
 20492  0
     public static final BitSet FOLLOW_IRI_in_builtInCall3199 = new BitSet(new long[]{0x0000000000000004L});
 20493  0
     public static final BitSet FOLLOW_expression_in_builtInCall3201 = new BitSet(new long[]{0x0000000000000008L});
 20494  0
     public static final BitSet FOLLOW_URI_in_builtInCall3211 = new BitSet(new long[]{0x0000000000000004L});
 20495  0
     public static final BitSet FOLLOW_expression_in_builtInCall3213 = new BitSet(new long[]{0x0000000000000008L});
 20496  0
     public static final BitSet FOLLOW_BNODE_in_builtInCall3223 = new BitSet(new long[]{0x0000000000000004L});
 20497  0
     public static final BitSet FOLLOW_expression_in_builtInCall3225 = new BitSet(new long[]{0x0000000000000008L});
 20498  0
     public static final BitSet FOLLOW_BNODE_in_builtInCall3234 = new BitSet(new long[]{0x0000000000000002L});
 20499  0
     public static final BitSet FOLLOW_RAND_in_builtInCall3242 = new BitSet(new long[]{0x0000000000000002L});
 20500  0
     public static final BitSet FOLLOW_ABS_in_builtInCall3251 = new BitSet(new long[]{0x0000000000000004L});
 20501  0
     public static final BitSet FOLLOW_expression_in_builtInCall3253 = new BitSet(new long[]{0x0000000000000008L});
 20502  0
     public static final BitSet FOLLOW_CEIL_in_builtInCall3263 = new BitSet(new long[]{0x0000000000000004L});
 20503  0
     public static final BitSet FOLLOW_expression_in_builtInCall3265 = new BitSet(new long[]{0x0000000000000008L});
 20504  0
     public static final BitSet FOLLOW_FLOOR_in_builtInCall3275 = new BitSet(new long[]{0x0000000000000004L});
 20505  0
     public static final BitSet FOLLOW_expression_in_builtInCall3277 = new BitSet(new long[]{0x0000000000000008L});
 20506  0
     public static final BitSet FOLLOW_ROUND_in_builtInCall3287 = new BitSet(new long[]{0x0000000000000004L});
 20507  0
     public static final BitSet FOLLOW_expression_in_builtInCall3289 = new BitSet(new long[]{0x0000000000000008L});
 20508  0
     public static final BitSet FOLLOW_CONCAT_in_builtInCall3299 = new BitSet(new long[]{0x0000000000000004L});
 20509  0
     public static final BitSet FOLLOW_expressionList_in_builtInCall3301 = new BitSet(new long[]{0x0000000000000008L});
 20510  0
     public static final BitSet FOLLOW_subStringExpression_in_builtInCall3310 = new BitSet(new long[]{0x0000000000000002L});
 20511  0
     public static final BitSet FOLLOW_STRLEN_in_builtInCall3319 = new BitSet(new long[]{0x0000000000000004L});
 20512  0
     public static final BitSet FOLLOW_expression_in_builtInCall3321 = new BitSet(new long[]{0x0000000000000008L});
 20513  0
     public static final BitSet FOLLOW_UCASE_in_builtInCall3331 = new BitSet(new long[]{0x0000000000000004L});
 20514  0
     public static final BitSet FOLLOW_expression_in_builtInCall3333 = new BitSet(new long[]{0x0000000000000008L});
 20515  0
     public static final BitSet FOLLOW_LCASE_in_builtInCall3343 = new BitSet(new long[]{0x0000000000000004L});
 20516  0
     public static final BitSet FOLLOW_expression_in_builtInCall3345 = new BitSet(new long[]{0x0000000000000008L});
 20517  0
     public static final BitSet FOLLOW_ENCODE_FOR_URI_in_builtInCall3355 = new BitSet(new long[]{0x0000000000000004L});
 20518  0
     public static final BitSet FOLLOW_expression_in_builtInCall3357 = new BitSet(new long[]{0x0000000000000008L});
 20519  0
     public static final BitSet FOLLOW_CONTAINS_in_builtInCall3367 = new BitSet(new long[]{0x0000000000000004L});
 20520  0
     public static final BitSet FOLLOW_expression_in_builtInCall3369 = new BitSet(new long[]{0x8640C00000004100L,0x806020C000C80600L,0x0000000000000100L,0x0000000000000008L});
 20521  0
     public static final BitSet FOLLOW_expression_in_builtInCall3371 = new BitSet(new long[]{0x0000000000000008L});
 20522  0
     public static final BitSet FOLLOW_STRSTARTS_in_builtInCall3381 = new BitSet(new long[]{0x0000000000000004L});
 20523  0
     public static final BitSet FOLLOW_expression_in_builtInCall3383 = new BitSet(new long[]{0x8640C00000004100L,0x806020C000C80600L,0x0000000000000100L,0x0000000000000008L});
 20524  0
     public static final BitSet FOLLOW_expression_in_builtInCall3385 = new BitSet(new long[]{0x0000000000000008L});
 20525  0
     public static final BitSet FOLLOW_STRENDS_in_builtInCall3395 = new BitSet(new long[]{0x0000000000000004L});
 20526  0
     public static final BitSet FOLLOW_expression_in_builtInCall3397 = new BitSet(new long[]{0x8640C00000004100L,0x806020C000C80600L,0x0000000000000100L,0x0000000000000008L});
 20527  0
     public static final BitSet FOLLOW_expression_in_builtInCall3399 = new BitSet(new long[]{0x0000000000000008L});
 20528  0
     public static final BitSet FOLLOW_STRBEFORE_in_builtInCall3409 = new BitSet(new long[]{0x0000000000000004L});
 20529  0
     public static final BitSet FOLLOW_expression_in_builtInCall3411 = new BitSet(new long[]{0x8640C00000004100L,0x806020C000C80600L,0x0000000000000100L,0x0000000000000008L});
 20530  0
     public static final BitSet FOLLOW_expression_in_builtInCall3413 = new BitSet(new long[]{0x0000000000000008L});
 20531  0
     public static final BitSet FOLLOW_STRAFTER_in_builtInCall3423 = new BitSet(new long[]{0x0000000000000004L});
 20532  0
     public static final BitSet FOLLOW_expression_in_builtInCall3425 = new BitSet(new long[]{0x8640C00000004100L,0x806020C000C80600L,0x0000000000000100L,0x0000000000000008L});
 20533  0
     public static final BitSet FOLLOW_expression_in_builtInCall3427 = new BitSet(new long[]{0x0000000000000008L});
 20534  0
     public static final BitSet FOLLOW_REPLACE_in_builtInCall3437 = new BitSet(new long[]{0x0000000000000004L});
 20535  0
     public static final BitSet FOLLOW_expression_in_builtInCall3439 = new BitSet(new long[]{0x8640C00000004100L,0x806020C000C80600L,0x0000000000000100L,0x0000000000000008L});
 20536  0
     public static final BitSet FOLLOW_expression_in_builtInCall3441 = new BitSet(new long[]{0x8640C00000004100L,0x806020C000C80600L,0x0000000000000100L,0x0000000000000008L});
 20537  0
     public static final BitSet FOLLOW_expression_in_builtInCall3443 = new BitSet(new long[]{0x0000000000000008L});
 20538  0
     public static final BitSet FOLLOW_YEAR_in_builtInCall3453 = new BitSet(new long[]{0x0000000000000004L});
 20539  0
     public static final BitSet FOLLOW_expression_in_builtInCall3455 = new BitSet(new long[]{0x0000000000000008L});
 20540  0
     public static final BitSet FOLLOW_MONTH_in_builtInCall3465 = new BitSet(new long[]{0x0000000000000004L});
 20541  0
     public static final BitSet FOLLOW_expression_in_builtInCall3467 = new BitSet(new long[]{0x0000000000000008L});
 20542  0
     public static final BitSet FOLLOW_DAY_in_builtInCall3477 = new BitSet(new long[]{0x0000000000000004L});
 20543  0
     public static final BitSet FOLLOW_expression_in_builtInCall3479 = new BitSet(new long[]{0x0000000000000008L});
 20544  0
     public static final BitSet FOLLOW_HOURS_in_builtInCall3489 = new BitSet(new long[]{0x0000000000000004L});
 20545  0
     public static final BitSet FOLLOW_expression_in_builtInCall3491 = new BitSet(new long[]{0x0000000000000008L});
 20546  0
     public static final BitSet FOLLOW_MINUTES_in_builtInCall3501 = new BitSet(new long[]{0x0000000000000004L});
 20547  0
     public static final BitSet FOLLOW_expression_in_builtInCall3503 = new BitSet(new long[]{0x0000000000000008L});
 20548  0
     public static final BitSet FOLLOW_SECONDS_in_builtInCall3513 = new BitSet(new long[]{0x0000000000000004L});
 20549  0
     public static final BitSet FOLLOW_expression_in_builtInCall3515 = new BitSet(new long[]{0x0000000000000008L});
 20550  0
     public static final BitSet FOLLOW_TIMEZONE_in_builtInCall3525 = new BitSet(new long[]{0x0000000000000004L});
 20551  0
     public static final BitSet FOLLOW_expression_in_builtInCall3527 = new BitSet(new long[]{0x0000000000000008L});
 20552  0
     public static final BitSet FOLLOW_TZ_in_builtInCall3537 = new BitSet(new long[]{0x0000000000000004L});
 20553  0
     public static final BitSet FOLLOW_expression_in_builtInCall3539 = new BitSet(new long[]{0x0000000000000008L});
 20554  0
     public static final BitSet FOLLOW_NOW_in_builtInCall3548 = new BitSet(new long[]{0x0000000000000002L});
 20555  0
     public static final BitSet FOLLOW_MD5_in_builtInCall3557 = new BitSet(new long[]{0x0000000000000004L});
 20556  0
     public static final BitSet FOLLOW_expression_in_builtInCall3559 = new BitSet(new long[]{0x0000000000000008L});
 20557  0
     public static final BitSet FOLLOW_SHA1_in_builtInCall3569 = new BitSet(new long[]{0x0000000000000004L});
 20558  0
     public static final BitSet FOLLOW_expression_in_builtInCall3571 = new BitSet(new long[]{0x0000000000000008L});
 20559  0
     public static final BitSet FOLLOW_SHA224_in_builtInCall3581 = new BitSet(new long[]{0x0000000000000004L});
 20560  0
     public static final BitSet FOLLOW_expression_in_builtInCall3583 = new BitSet(new long[]{0x0000000000000008L});
 20561  0
     public static final BitSet FOLLOW_SHA256_in_builtInCall3593 = new BitSet(new long[]{0x0000000000000004L});
 20562  0
     public static final BitSet FOLLOW_expression_in_builtInCall3595 = new BitSet(new long[]{0x0000000000000008L});
 20563  0
     public static final BitSet FOLLOW_SHA384_in_builtInCall3605 = new BitSet(new long[]{0x0000000000000004L});
 20564  0
     public static final BitSet FOLLOW_expression_in_builtInCall3607 = new BitSet(new long[]{0x0000000000000008L});
 20565  0
     public static final BitSet FOLLOW_SHA512_in_builtInCall3617 = new BitSet(new long[]{0x0000000000000004L});
 20566  0
     public static final BitSet FOLLOW_expression_in_builtInCall3619 = new BitSet(new long[]{0x0000000000000008L});
 20567  0
     public static final BitSet FOLLOW_COALESCE_in_builtInCall3629 = new BitSet(new long[]{0x0000000000000004L});
 20568  0
     public static final BitSet FOLLOW_expressionList_in_builtInCall3631 = new BitSet(new long[]{0x0000000000000008L});
 20569  0
     public static final BitSet FOLLOW_IF_in_builtInCall3641 = new BitSet(new long[]{0x0000000000000004L});
 20570  0
     public static final BitSet FOLLOW_expression_in_builtInCall3643 = new BitSet(new long[]{0x8640C00000004100L,0x806020C000C80600L,0x0000000000000100L,0x0000000000000008L});
 20571  0
     public static final BitSet FOLLOW_expression_in_builtInCall3645 = new BitSet(new long[]{0x8640C00000004100L,0x806020C000C80600L,0x0000000000000100L,0x0000000000000008L});
 20572  0
     public static final BitSet FOLLOW_expression_in_builtInCall3647 = new BitSet(new long[]{0x0000000000000008L});
 20573  0
     public static final BitSet FOLLOW_STRLANG_in_builtInCall3657 = new BitSet(new long[]{0x0000000000000004L});
 20574  0
     public static final BitSet FOLLOW_expression_in_builtInCall3659 = new BitSet(new long[]{0x8640C00000004100L,0x806020C000C80600L,0x0000000000000100L,0x0000000000000008L});
 20575  0
     public static final BitSet FOLLOW_expression_in_builtInCall3661 = new BitSet(new long[]{0x0000000000000008L});
 20576  0
     public static final BitSet FOLLOW_STRDT_in_builtInCall3671 = new BitSet(new long[]{0x0000000000000004L});
 20577  0
     public static final BitSet FOLLOW_expression_in_builtInCall3673 = new BitSet(new long[]{0x8640C00000004100L,0x806020C000C80600L,0x0000000000000100L,0x0000000000000008L});
 20578  0
     public static final BitSet FOLLOW_expression_in_builtInCall3675 = new BitSet(new long[]{0x0000000000000008L});
 20579  0
     public static final BitSet FOLLOW_SAMETERM_in_builtInCall3685 = new BitSet(new long[]{0x0000000000000004L});
 20580  0
     public static final BitSet FOLLOW_expression_in_builtInCall3687 = new BitSet(new long[]{0x8640C00000004100L,0x806020C000C80600L,0x0000000000000100L,0x0000000000000008L});
 20581  0
     public static final BitSet FOLLOW_expression_in_builtInCall3689 = new BitSet(new long[]{0x0000000000000008L});
 20582  0
     public static final BitSet FOLLOW_ISIRI_in_builtInCall3699 = new BitSet(new long[]{0x0000000000000004L});
 20583  0
     public static final BitSet FOLLOW_expression_in_builtInCall3701 = new BitSet(new long[]{0x0000000000000008L});
 20584  0
     public static final BitSet FOLLOW_ISURI_in_builtInCall3711 = new BitSet(new long[]{0x0000000000000004L});
 20585  0
     public static final BitSet FOLLOW_expression_in_builtInCall3713 = new BitSet(new long[]{0x0000000000000008L});
 20586  0
     public static final BitSet FOLLOW_ISBLANK_in_builtInCall3723 = new BitSet(new long[]{0x0000000000000004L});
 20587  0
     public static final BitSet FOLLOW_expression_in_builtInCall3725 = new BitSet(new long[]{0x0000000000000008L});
 20588  0
     public static final BitSet FOLLOW_ISLITERAL_in_builtInCall3736 = new BitSet(new long[]{0x0000000000000004L});
 20589  0
     public static final BitSet FOLLOW_expression_in_builtInCall3738 = new BitSet(new long[]{0x0000000000000008L});
 20590  0
     public static final BitSet FOLLOW_ISNUMERIC_in_builtInCall3748 = new BitSet(new long[]{0x0000000000000004L});
 20591  0
     public static final BitSet FOLLOW_expression_in_builtInCall3750 = new BitSet(new long[]{0x0000000000000008L});
 20592  0
     public static final BitSet FOLLOW_regexExpression_in_builtInCall3759 = new BitSet(new long[]{0x0000000000000002L});
 20593  0
     public static final BitSet FOLLOW_existsFunction_in_builtInCall3767 = new BitSet(new long[]{0x0000000000000002L});
 20594  0
     public static final BitSet FOLLOW_notExistsFunction_in_builtInCall3775 = new BitSet(new long[]{0x0000000000000002L});
 20595  0
     public static final BitSet FOLLOW_REGEX_in_regexExpression3793 = new BitSet(new long[]{0x0000000000000004L});
 20596  0
     public static final BitSet FOLLOW_expression_in_regexExpression3795 = new BitSet(new long[]{0x8640C00000004108L,0x806020C000C80600L,0x0000000000000100L,0x0000000000000008L});
 20597  0
     public static final BitSet FOLLOW_SUBSTR_in_subStringExpression3819 = new BitSet(new long[]{0x0000000000000004L});
 20598  0
     public static final BitSet FOLLOW_expression_in_subStringExpression3821 = new BitSet(new long[]{0x8640C00000004108L,0x806020C000C80600L,0x0000000000000100L,0x0000000000000008L});
 20599  0
     public static final BitSet FOLLOW_EXISTS_in_existsFunction3845 = new BitSet(new long[]{0x0000000000000004L});
 20600  0
     public static final BitSet FOLLOW_groupGraphPattern_in_existsFunction3847 = new BitSet(new long[]{0x0000000000000008L});
 20601  0
     public static final BitSet FOLLOW_NOT_EXISTS_in_notExistsFunction3866 = new BitSet(new long[]{0x0000000000000004L});
 20602  0
     public static final BitSet FOLLOW_groupGraphPattern_in_notExistsFunction3868 = new BitSet(new long[]{0x0000000000000008L});
 20603  0
     public static final BitSet FOLLOW_COUNT_in_aggregate3887 = new BitSet(new long[]{0x0000000000000004L});
 20604  0
     public static final BitSet FOLLOW_DISTINCT_in_aggregate3889 = new BitSet(new long[]{0x8660C00000004108L,0x806020C000C80600L,0x0000000000000100L,0x0000000000000008L});
 20605  0
     public static final BitSet FOLLOW_ASTERISK_in_aggregate3892 = new BitSet(new long[]{0x8640C00000004108L,0x806020C000C80600L,0x0000000000000100L,0x0000000000000008L});
 20606  0
     public static final BitSet FOLLOW_expression_in_aggregate3895 = new BitSet(new long[]{0x8640C00000004108L,0x806020C000C80600L,0x0000000000000100L,0x0000000000000008L});
 20607  0
     public static final BitSet FOLLOW_SUM_in_aggregate3906 = new BitSet(new long[]{0x0000000000000004L});
 20608  0
     public static final BitSet FOLLOW_DISTINCT_in_aggregate3908 = new BitSet(new long[]{0x8660C00000004100L,0x806020C000C80600L,0x0000000000000100L,0x0000000000000008L});
 20609  0
     public static final BitSet FOLLOW_expression_in_aggregate3911 = new BitSet(new long[]{0x0000000000000008L});
 20610  0
     public static final BitSet FOLLOW_MIN_in_aggregate3921 = new BitSet(new long[]{0x0000000000000004L});
 20611  0
     public static final BitSet FOLLOW_DISTINCT_in_aggregate3923 = new BitSet(new long[]{0x8660C00000004100L,0x806020C000C80600L,0x0000000000000100L,0x0000000000000008L});
 20612  0
     public static final BitSet FOLLOW_expression_in_aggregate3926 = new BitSet(new long[]{0x0000000000000008L});
 20613  0
     public static final BitSet FOLLOW_MAX_in_aggregate3936 = new BitSet(new long[]{0x0000000000000004L});
 20614  0
     public static final BitSet FOLLOW_DISTINCT_in_aggregate3938 = new BitSet(new long[]{0x8660C00000004100L,0x806020C000C80600L,0x0000000000000100L,0x0000000000000008L});
 20615  0
     public static final BitSet FOLLOW_expression_in_aggregate3941 = new BitSet(new long[]{0x0000000000000008L});
 20616  0
     public static final BitSet FOLLOW_AVG_in_aggregate3951 = new BitSet(new long[]{0x0000000000000004L});
 20617  0
     public static final BitSet FOLLOW_DISTINCT_in_aggregate3953 = new BitSet(new long[]{0x8660C00000004100L,0x806020C000C80600L,0x0000000000000100L,0x0000000000000008L});
 20618  0
     public static final BitSet FOLLOW_expression_in_aggregate3956 = new BitSet(new long[]{0x0000000000000008L});
 20619  0
     public static final BitSet FOLLOW_SAMPLE_in_aggregate3966 = new BitSet(new long[]{0x0000000000000004L});
 20620  0
     public static final BitSet FOLLOW_DISTINCT_in_aggregate3968 = new BitSet(new long[]{0x8640C00000004100L,0x806020C000C80600L,0x0000000000000100L,0x0000000000000008L});
 20621  0
     public static final BitSet FOLLOW_expression_in_aggregate3971 = new BitSet(new long[]{0x0000000000000008L});
 20622  0
     public static final BitSet FOLLOW_GROUP_CONCAT_in_aggregate3981 = new BitSet(new long[]{0x0000000000000004L});
 20623  0
     public static final BitSet FOLLOW_DISTINCT_in_aggregate3983 = new BitSet(new long[]{0x8660C00000004100L,0x806020C000C80600L,0x0000000000000100L,0x0000000000000008L});
 20624  0
     public static final BitSet FOLLOW_expression_in_aggregate3986 = new BitSet(new long[]{0x0000000000000008L,0x0000000000000000L,0x0007800000000000L});
 20625  0
     public static final BitSet FOLLOW_string_in_aggregate3988 = new BitSet(new long[]{0x0000000000000008L});
 20626  0
     public static final BitSet FOLLOW_FUNCTION_in_iriRefOrFunction4012 = new BitSet(new long[]{0x0000000000000004L});
 20627  0
     public static final BitSet FOLLOW_iriRef_in_iriRefOrFunction4016 = new BitSet(new long[]{0x0000000000000400L});
 20628  0
     public static final BitSet FOLLOW_ARG_LIST_in_iriRefOrFunction4019 = new BitSet(new long[]{0x0000000000000004L});
 20629  0
     public static final BitSet FOLLOW_argList_in_iriRefOrFunction4024 = new BitSet(new long[]{0x0000000000000008L});
 20630  0
     public static final BitSet FOLLOW_FUNCTION_in_iriRefOrFunction4036 = new BitSet(new long[]{0x0000000000000004L});
 20631  0
     public static final BitSet FOLLOW_iriRef_in_iriRefOrFunction4040 = new BitSet(new long[]{0x0000000000000008L});
 20632  0
     public static final BitSet FOLLOW_string_in_rdfLiteral4058 = new BitSet(new long[]{0x0000000000000002L,0x0000001000000000L,0x0000000000800000L});
 20633  0
     public static final BitSet FOLLOW_LANGTAG_in_rdfLiteral4061 = new BitSet(new long[]{0x0000000000000002L});
 20634  0
     public static final BitSet FOLLOW_REFERENCE_in_rdfLiteral4066 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000000000000600L});
 20635  0
     public static final BitSet FOLLOW_iriRef_in_rdfLiteral4068 = new BitSet(new long[]{0x0000000000000002L});
 20636  0
     public static final BitSet FOLLOW_numericLiteralUnsigned_in_numericLiteral4088 = new BitSet(new long[]{0x0000000000000002L});
 20637  0
     public static final BitSet FOLLOW_numericLiteralPositive_in_numericLiteral4096 = new BitSet(new long[]{0x0000000000000002L});
 20638  0
     public static final BitSet FOLLOW_numericLiteralNegative_in_numericLiteral4104 = new BitSet(new long[]{0x0000000000000002L});
 20639  0
     public static final BitSet FOLLOW_IRI_REF_in_iriRef4287 = new BitSet(new long[]{0x0000000000000002L});
 20640  0
     public static final BitSet FOLLOW_prefixedName_in_iriRef4295 = new BitSet(new long[]{0x0000000000000002L});
 20641  0
     public static final BitSet FOLLOW_BLANK_NODE_LABEL_in_blankNode4337 = new BitSet(new long[]{0x0000000000000002L});
 20642  0
     public static final BitSet FOLLOW_anon_in_blankNode4345 = new BitSet(new long[]{0x0000000000000002L});
 20643  0
     public static final BitSet FOLLOW_OPEN_SQUARE_BRACKET_in_anon4362 = new BitSet(new long[]{0x0000000040000000L});
 20644  0
     public static final BitSet FOLLOW_CLOSE_SQUARE_BRACKET_in_anon4364 = new BitSet(new long[]{0x0000000000000002L});
 20645  
 
 20646  
 }